Spring学习之路（三）bean注解管理AOP操作

在类上面、方法上面、属性上面添加注解；并用bean来管理；

书写方法：@注解名称（属性名称=值）

第一步：导入jar包

　　导入spring-aop.jar（spring注解包）；

第二步：创建实体类（注解对象）

package com.aop;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * value的值是自定义属性值
 * @Component(value="user")
 * @Controller    web层
 * @Service        业务层
 * @Repository    持久层
 *
 * (value="xx" 相当于      <bean id="xx" class="路径"></bean>
 * 四种注解方式，功能都相同
 */
@Component(value="user")
@Scope(value="prototype")    //创建是多例还是单例
public class AopUser {
    public void add() {
        System.out.println("add---------------");
    }
}

第三步：配置注解文件，引入约束

　　核心约束：spring-beans.xsd

　　注解约束：spring-context.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        <!-- 开启注解扫描 -->
        <!-- base-package :扫描到包里边的所有是否存在注解 -->
        <context:component-scan base-package="com.aop"></context:component-scan>
      <!--   <context:annotation-config></context:annotation-config> 扫描属性上的注解 -->
</beans>

第四步：测试

    @Test
    public void test() {
        //加载 spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
//        得到注解对象 value的值
        AopUser user =  (AopUser) context.getBean("user");
        user.add();
    }

多例练习

package com.ioc;

import javax.annotation.Resource;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Service(value="user")
public class User {
    //@Autowired    两种方法都可以
    @Resource(name="userDao")//获取userDao注解名称
    private UserDao userDao;
    //得到dao对象，在使用注解方式时不需要set方法
    public void add() {
        System.out.println("user=====--------");
        userDao.add();
    }
}
//userDao类

@Component(value="userDao")
public class UserDao {
    public void add() {
        System.out.println("dao---------------");
    }
}

//测试；配置文件同上
@Test
public void test() {
    //加载 spring 配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
//    得到注解对象 value的值
    User user =  (User) context.getBean("user");
    user.add();
}

AOP操作

　　1、导入jar包（看spring入门）

　　2、创建实体类

package com.ioc;

import javax.annotation.Resource;

public class User {
    public void add() {
        System.out.println("user=====--------");
    }
}

// userDao类

import org.aspectj.lang.ProceedingJoinPoint;

public class UserDao {
    public void add() {
        System.out.println("前置增强---------------");
    }
    public void after(){
        System.out.println("后置增强------------");
    }

//    环绕通知
    public void arount(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
//        方法之前
        System.out.println("方法之前执行----------------");
//        执行增强的方法
        proceedingJoinPoint.proceed();
//        方法之后
        System.out.println("方法后执行----------------");
    }
}

　　3、配置bean文件（导入aop约束）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">  

         <!-- 配置对象 -->
         <bean id="user" class="com.ioc.User"></bean>
         <bean id="userDao" class="com.ioc.UserDao"></bean>
         <!-- 配置aop操作 -->
         <aop:config>
             <!-- 配置切入点 -->
              <!-- execution（<访问修饰符>？<返回类型><方法名>(<参数>)<异常>） -->
             <aop:pointcut expression="execution(* com.ioc.User.*(..))" id="pointcut1"/>
             <!-- 配置切面 ；把增强放到方法上面-->
             <aop:aspect ref="userDao">
                 <!-- 配置增强类型；
                     method：设置 userdao中的增强的方法名
                     pointcut-ref：指向切入点ID值
                     就是先执行userDao里的方法，再执行user里的方法
                  -->
                 <aop:before method="add" pointcut-ref="pointcut1"/>
                 <!-- 后置增强 执行user的方法之后才会执行 after方法 -->
                 <aop:after-returning method="after" pointcut-ref="pointcut1"/>
                 <!-- 在执行user方法的前后开始执行其中的方法 -->
                 <aop:around method="arount" pointcut-ref="pointcut1"/>
             </aop:aspect>
         </aop:config>
</beans>

　　4、测试

package com.junit;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ioc.User;

public class Text {

    @Test
    public void test() {
        //加载 spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
//        得到注解对象 value的值
        User user =  (User) context.getBean("user");
        user.add();
    }

}