Spring笔记2

Bean生命周期

1 实例化
2 注入属性
3 BeanNameAware
4 BeanFactoryAware
5 ApplicationContextAware
6 BeanPostProcessor,ProcessBeforeInitialization
7 Initilalization
8 BeanPostProcessor,ProcessAfterInitialization
9 以上工作完成后就可以使用bean
10 DisposableBean destroy（或者配置destroy-method）
https://www.cnblogs.com/kenshinobiy/p/4652008.html

AOP

AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

AOP 关键术语　

1. 目标类target：就是我们需要增强的那个类，target
2. 代理类proxy：就是我们自定义的那个代理的对象proxy
3. 连接点joinPoint：连接点说白了就是我们的目标类里面所有的方法。
4. 切入点pointCut：切入点说白了就是那些在目标类中我们实际上增强的方法。
5. 织入weave：说白了就是将我们的代理类中需要增强的方法放入到目标类中去执行的过程，就叫织入
6. 引介Introduction：是对我们的类中的方法或者属性进行一些创建的过程
7. 通知advice：说白了就是将我们代理对象中的方法应用到目标类的过程中产生的结果。
8. 切面aspect：说白了就是我们的所有的连接点和代理对象的方法组成在一起构成了我们的切面

jdk的代理方式来进行增强

public class CustomerServiceImpl implements CustomerService {

    @Override
    public void rent() {
        System.out.println("I want to rent my house");

    }

    @Override
    public void hello(String str) {
        System.out.println("hello: " + str);

    }

}

/*Proxy.newProxyInstance(loader, interfaces, h);
    loader:一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
    interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
    h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上*/

/*public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}
    proxy:指代我们所代理的那个真实对象
    method:指代的是我们所要调用真实对象的某个方法的Method对象
    args:指代的是调用真实对象某个方法时接受的参数*/

public class CustomerProxy implements InvocationHandler {

    private CustomerService customerService;

    public CustomerProxy(CustomerService customerService){
        this.customerService=customerService;
    }

    public CustomerService createCustomerJdkProxy(){
        Object newProxyInstance = Proxy.newProxyInstance(customerService.getClass().getClassLoader(),
                customerService.getClass().getInterfaces(), this);
        return (CustomerService)newProxyInstance;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Method:" + method.getName());
        if(method.getName().equals("rent")){
            //在代理真实对象前我们可以添加一些自己的操作
            System.out.println("before rent house");
            Object invoke = method.invoke(customerService, args);
            //在代理真实对象后我们也可以添加一些自己的操作
            System.out.println("after rent house");
            return invoke;
        }
        return method.invoke(customerService, args);
    }

}

<bean id="customerService" class="com.itheima.spring.demo3.jdkproxy.CustomerServiceImpl"></bean>

public class JdkProxy {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerService  customerService= (CustomerService)context.getBean("customerService");
        CustomerService jdkProxy = new CustomerProxy(customerService).createCustomerJdkProxy();
        jdkProxy.rent();
        jdkProxy.hello("World");
    }
}

cglib的代理方式来进行增强

public class CustomerServiceImpl {

    public void rent() {
        System.out.println("I want to rent my house");
    }

    public void hello(String str) {
        System.out.println("hello: " + str);
    }

}

public class CustomerProxy implements MethodInterceptor{

    private CustomerServiceImpl customerServiceImpl;

    public CustomerProxy(CustomerServiceImpl customerServiceImpl) {
        this.customerServiceImpl = customerServiceImpl;
    }

    public CustomerServiceImpl createCustomerCglibProxy(){
        //1.创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        //2.设置需要增强的父类
        enhancer.setSuperclass(customerServiceImpl.getClass());
        //3.设置回调
        enhancer.setCallback(this);
        //4.执行代理类
        Object create = enhancer.create();
        return (CustomerServiceImpl)create;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("Method:" + method.getName());
        if(method.getName().equals("rent")){
            //在代理真实对象前我们可以添加一些自己的操作
            System.out.println("before rent house");
            Object invokeSuper = methodProxy.invokeSuper(proxy, args);
            //在代理真实对象后我们也可以添加一些自己的操作
            System.out.println("after rent house");
            return invokeSuper;
        }
        return methodProxy.invokeSuper(proxy, args);
    }

}

public class CglibProxy {

    @Test
    public void testCglibProxy(){
        CustomerServiceImpl customerServiceImpl = new CustomerServiceImpl();
        CustomerServiceImpl cglibProxy = new CustomerProxy(customerServiceImpl).createCustomerCglibProxy();
        cglibProxy.rent();
        cglibProxy.hello("World");
    }

}

AOP基于xml配置的方式实现

public class CustomerServiceImpl {

    public void rent() {
        System.out.println("I want to rent my house");
    }

    public void hello(String str) {
        System.out.println("hello: " + str);
    }

}

public class CustomerProxy {
    public void strongMethod(){
        System.out.println("$100 rent house");
    }
}

<bean id="customerService" class="com.itheima.spring.demo3.xml.CustomerServiceImpl"></bean>
<bean id="customerProxyAspect" class="com.itheima.spring.demo3.xml.CustomerProxy"></bean>
<aop:config>
    <aop:pointcut expression="execution(* com.itheima.spring.demo3.xml.*.rent*(..))" id="pointcut1"/>
    <aop:aspect ref="customerProxyAspect">
        <aop:after-returning method="strongMethod" pointcut-ref="pointcut1" />
    </aop:aspect>
</aop:config>

public class XmlAspect {

    @Test
    public void testXmlAspect(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerService bean= (CustomerService)context.getBean("customerService");
        bean.rent();
        bean.hello("World");
    }

}

AOP基于注解的方式实现

@Service
public class CustomerServiceImpl implements CustomerService {

    @Override
    public String rent() {
        System.out.println("I want to rent my house");
        return "张三";
    }

    @Override
    public void hello(String str) {
        System.out.println("hello: " + str);

    }

}

@Component
@Aspect
public class CustomerProxy {

    @AfterReturning(value="execution(* com.itheima.spring.demo3.xml.*.rent*(..))",returning="object")
    public void strongMethod(Object object){
        System.out.println(object + " $100 rent house");
    }

}

<context:component-scan base-package="com.itheima.spring.demo3.xml"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

public class XmlAspect {

    @Test
    public void testXmlAspect(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerService bean= (CustomerService)context.getBean("customerServiceImpl");
        bean.rent();
        bean.hello("World");
    }

}

Spring 切面可以应用五种类型的通知：

1. before：前置通知，在一个方法执行前被调用。
2. after: 在方法执行之后调用的通知，无论方法执行是否成功。
3. after-returning: 仅当方法成功完成后执行的通知。
4. after-throwing: 在方法抛出异常退出时执行的通知。
5. around: 在方法执行之前和之后调用的通知。