Spring框架学习第二天

1.使用注解配置Spring

　　1.导包基本包4个+2个Spring+aop

　　2.导入新的命名空间context

　　3.开启注解扫描功能

<!-- 扫描着这包下的注解 -->
    <context:component-scan base-package="cn.xiaou.domain"></context:component-scan>

　　4.在bean类的操作

//将对象注册到容器
@Component("s1")
/*
 * @Service("s1")
 * @Controller("s1")
 * @Repository("s1")
 */
/*修改对象的作用范围
 * @Scope("prototype") 多例
 * @Scope("singleton") 单例 默认
 */
@Scope("singleton")
public class Student {
    //值注入，不推荐因为是通过反射Field赋值，破坏来来封装性
    @Value("zjj")
    private String name;
    
    private Integer age;
    /*
     * @Resource(name="class1") 手动装配
     * @Autowired 
     * 自动装配根据类型进行装配
     * 如果出现多个类型一样的对象，将无法控制注入的是那个对象
     */
    @Resource(name="class1")
    private Class clazz;
    
    public Class getClazz() {
        return clazz;
    }
    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //值注入推荐使用
    @Value("18")
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", clazz=" + clazz + "]";
    }
    
    @PostConstruct
    public void init() {
        System.out.println("我是初始方法");
    }
    @PreDestroy
    public void destory() {
        System.out.println("我是摧毁方法");
    }
}

2.aop

　　1.aop的名词学习

　　　　　　joinpoint（连接点）：目标对象中，所有可以增强的方法

　　　　　　pointcut（切入点）：目标对象，已经增强的方法

　　　　　　Advice（通知/增强）：增强的代码

　　　　　　Target（目标对象）：被代理对象

　　　　　　weaving（织入）：将通知应用切入点的过程

　　　　　　Proxy（代理）：将通知织入到目标对象之后，形成的代理对象

　　　　　　aspect（切面）：切入点和通知

　　2.Spring实现的aop　　

　　　　　1.动态代理：通过接口代理

　　　　　2.cglib代理：不用通过接口，而是通过继承实现代理

　　　　　在Spring中是先判断代理类是否可以通过接口代理如果不行则通过cglib代理

　　3.Spring动态代理实现

　　　　　　1.导包（4个基本包+aspects切面包+aop包）第三方的jar包（aopalliance和weaver）

　　　　　　2.目标类　

public class ProxyDemoImpl implements ProxyDemo{

    @Override
    public void save() {
        System.out.println("保存中");
    }

    @Override
    public void query() {
        System.out.println("查询中");
    }

    @Override
    public void update() {
        System.out.println("更新中");
    }

}

　　　　　　3.准备通知

public class MyAdvice {
    public void before() {
        System.out.println("前置通知");
    }
    
    public void afterRunning() {
        System.out.println("这是后置通知");
    }
    
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知前置部分");
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知后置部分");
        return proceed;
    }
    
    public void afterException() {
        System.out.println("异常");
    }
    
    public void after() {
        System.out.println("这是后置通知");
    }
}

　　　　4.配置进行织入，将通知织入目标对象中

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.springframework.org/schema/beans"
    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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
        
    <bean name="ProxyDemo"  class="cn.xiaou.proxy.ProxyDemoImpl"></bean>
    <bean name="myAdvice" class="cn.xiaou.proxy.MyAdvice"></bean>
    <!-- 动态代理配置 -->
    <aop:config>
        <!-- 配置切点 -->
        <aop:pointcut expression="execution(* cn.xiaou.proxy.*DemoImpl.*(..))" id="pc"/>
        <!-- 对切面进行配置 -->
        <aop:aspect ref="myAdvice">
            <!-- 对前置通知方法配置 -->
            <aop:before method="before" pointcut-ref="pc"/>
            <!-- 对后置通知方法配置 如果报错就不执行-->
            <aop:after-returning method="afterRunning" pointcut-ref="pc"/>
            <!-- 这是环绕通知，在前后都会执行 -->
            <aop:around method="around" pointcut-ref="pc"/>
            <!--  这是异常通知 -->
            <aop:after-throwing method="afterException" pointcut-ref="pc"/>
            <!-- 这是前置通知，无论有无异常都会执行 -->
            <aop:after method="after" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>
</beans>