Spring——Spring AOP1(代理模式Proxy)

代理（Proxy）模式

1.创建工程

2.代理（Proxy）模式介绍

• 作用：通过代理可以控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即： AOP的微观实现！）
• 
• 核心角色- 抽象角色(接口)：定义公共对外方法- 真实角色（周杰伦）：实现抽象角色，定义真实角色所要实现的业务逻辑，- 代理角色（代理人）：实现抽象角色，是真实角色的代理，通过调用真实角色的方法来完成业务逻辑，并可以附加自己的操作。

3.静态代理

3.1.抽象角色

packagecom.wt.proxy.StaticProxy;publicinterfaceStar{/**
     * 面谈
     */voidconfer();/**
     * 签合同
     */voidsignContract();/**
     * 订票
     */voidbookTicket();/**
     * 唱歌
     */voidsing();/**
     * 收钱
     */voidcollectMoney();}

3.2.真正角色（周杰伦）

packagecom.wt.proxy.StaticProxy;publicclassRealStarimplementsStar{publicvoidbookTicket(){}publicvoidcollectMoney(){}publicvoidconfer(){}publicvoidsignContract(){}publicvoidsing(){System.out.println("RealStar(周杰伦本人).sing()");}}

3.3.代理角色（经纪人）

packagecom.wt.proxy.StaticProxy;publicclassProxyStarimplementsStar{privateStar star;publicProxyStar(Star star){super();this.star = star;}publicvoidbookTicket(){System.out.println("ProxyStar.bookTicket()");}publicvoidcollectMoney(){System.out.println("ProxyStar.collectMoney()");}publicvoidconfer(){System.out.println("ProxyStar.confer()");}publicvoidsignContract(){System.out.println("ProxyStar.signContract()");}publicvoidsing(){
        star.sing();}}

3.4.测试

packagecom.wt.proxy.StaticProxy;publicclassClient{publicstaticvoidmain(String[] args){Star proxy =newProxyStar(newRealStar());
        
        proxy.confer();
        proxy.signContract();
        proxy.bookTicket();
        proxy.sing();
        
        proxy.collectMoney();}}

3.5.静态代理的缺点

1. 代理类和实现类实现了相同的接口，这样就出现了大量的代码重复。
2. 代理对象只服务于一种类型的对象。如果要服务多类型的对象，例如代码是只为UserService类的访问提供了代理，但是还要为其他类如DeptService类提供代理的话，就需要我们再次添加代理DeptService的代理类。

4.jdk动态代理

4.1.抽象角色

publicinterfaceStar{/**
     * 唱歌
     */voidsing();}

4.2.真正角色（周杰伦）

packagecom.wt.JdkProxy;//真实角色(周杰伦)publicclassRealStarimplementsStar{//优点：此时代码不再重复publicvoidsing(){System.out.println("周杰伦：快使用双截棍,哼哼哈嘿....");}}

4.3.代理角色（经纪人）

packagecom.wt.JdkProxy;importjava.lang.reflect.InvocationHandler;importjava.lang.reflect.Method;importjava.lang.reflect.Proxy;//代理类工厂publicclassProxyFactory{//优点：此时可以代理任意类型的对象//真实角色(周杰伦)privateObject realObj;publicProxyFactory(Object realObj){this.realObj = realObj;}//获得代理对象publicObjectgetProxyObject(){/**
         * Proxy：作用创建代理对象
         *      ClassLoader loader：类加载器
         *      Class<?>[] interfaces：真实角色实现的接口，根据接口生成代理类
         *      InvocationHandler h：增强的逻辑，即如何代理(宋吉吉要做的事)
         */returnProxy.newProxyInstance(
                realObj.getClass().getClassLoader(),
                realObj.getClass().getInterfaces(),newInvocationHandler(){/**
                     *
                     * @param proxy：代理类，一般不用
                     * @param method：要调用的方法
                     * @param args：调用方法时的参数
                     * @return
                     * @throws Throwable
                     */publicObjectinvoke(Object proxy,Method method,Object[] args)throwsThrowable{System.out.println("真正的方法执行前！");System.out.println("面谈，签合同，预付款，订机票");Object result = method.invoke(realObj, args);System.out.println("真正的方法执行后！");System.out.println("收尾款");return result;}});}}

4.4.测试

publicclassClient{publicstaticvoidmain(String[] args){//获得代理对象Star proxyObject =(Star)newProxyFactory(newRealStar()).getProxyObject();System.out.println(proxyObject.getClass());//class com.sun.proxy.$Proxy0
        proxyObject.sing();}}

5.Cglib动态代理

cglib与动态代理最大的区别就是：

• 使用jdk动态代理的对象必须实现一个接口
• 使用cglib代理的对象则无需实现接口

CGLIB是第三方提供的包，所以需要引入jar包的坐标：

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>2.2.2</version></dependency>

如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

5.1.真正角色

packagecom.wt.proxy.CglibProxy;publicclassRealStar{publicvoidsing(){System.out.println("RealStar(周杰伦本人).sing()");}}

5.2.代理角色（经纪人）

packagecom.wt.proxy.CglibProxy;importorg.springframework.cglib.proxy.Enhancer;importorg.springframework.cglib.proxy.MethodInterceptor;importorg.springframework.cglib.proxy.MethodProxy;importjava.lang.reflect.Method;//代理工厂publicclassProxyFactoryimplementsMethodInterceptor{//真实角色privateObject realObj;publicProxyFactory(Object realObj){this.realObj = realObj;}/**'
     * 获得子类代理对象
     * @return
     */publicObjectgetProxyObject(){//工具类Enhancer en =newEnhancer();//设置父类
        en.setSuperclass(realObj.getClass());//设置回调函数
        en.setCallback(this);//创建子类代理对象return en.create();}/*
        在子类中调用父类的方法
            intercept方法参数说明：
                obj ： 代理对象
                method ： 真实对象中的方法的Method实例
                args ： 实际参数
                methodProxy ：代理对象中的方法的method实例
     */publicObjectintercept(Object obj,Method method,Object[] args,MethodProxy methodProxy)throwsThrowable{System.out.println("真正的方法执行前！");System.out.println("面谈，签合同，预付款，订机票");Object result = method.invoke(realObj, args);System.out.println("真正的方法执行后！");System.out.println("收尾款");return object;}}

5.3.测试

packagecom.by.proxy.CglibProxy;//测试类publicclassClient{publicstaticvoidmain(String[] args){//获取代理对象RealStar proxyObject =(RealStar)newProxyFactory(newRealStar()).getProxyObject();
        proxyObject.sing();}}