Spring静态代理与动态代理

代理模式

1、什么是代理模式？

　　真实生活中有一种房屋中介是这样的，租客根本就不知道房东是谁，一切签合同、交租金、交钥匙等操作都直接和中介公司发生。我们把这种模式称之为代理模式。

　　代理模式：客户端直接使用的都是代理对象，不知道目标对象是谁，此时代理对象可以在客户端和目标对象之间起到中介的作用。

2、特点

　　代理对象完全包含目标对象，客户端使用的都是代理对象的方法，和目标对象没有直接关系

3、职责

　　把不是目标对象该做的事情从目标对象上撇开——职责清晰。

4、分类

　　静态代理：在程序运行前就已经存在代理类的字节码文件，代理对象和目标对象的关系在运行前就确定了。

　　动态代理：动态代理类是在程序运行期间由JVM通过反射等机制动态的生成的，所以不存在代理类的字节码文件。代理对象和真实对象的关系是在程序运行事情才确定的。

静态代理

1、在程序运行前就存在代理类的字节码文件，代理对象和真实对象的关系在运行之前就确定了。

2、优点:

　　1.被代理的业务类只需要做好自己的业务，实现了责任分离，保证了业务类的重用性

　　2.将业务类隐藏起来，起到了保护作用

3、 缺点：

　　1.代理对象的某个接口只服务于某一个业务对象，每个真实对象都得创建一个代理对象

　　2.如果需要代理的方法很多，则要为每一种方法都进行处理

　　3.如果接口增加一个方法，除了所有实现类需要实现这个方法外，代理类也需要实现，增加了代码的复杂度和成本

4、代码示例

结构：

　　　　

 

 

 代码：

public class TransactionManager {

    public void begin(){
        System.out.println("开启事务###");
    }
    public void commit(){
        System.out.println("提交事务++++++");
    }
    public void rollback(){
        System.out.println("回滚事务....");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test</groupId>
    <artifactId>spring03</artifactId>
    <version>1.0.0</version>
    <properties>
        <!--
            定义全局变量:变量名为project.spring.version
        -->
        <project.spring.version>5.0.0.RELEASE</project.spring.version>

    </properties>
    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${project.spring.version}</version>
        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

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

    <!--事务管理器-->
    <bean id="txManager" class="com.test.class01_static.tx.TransactionManager"/>

    <bean id="userDao" class="com.test.class01_static.dao.impl.UserDaoImpl"/>

    <!--代理对象，属性中的userService和Service为同一个实现类，使用id区分-->
    <bean id="proxy" class="com.test.class01_static.proxy.UserServiceImplProxy">
        <property name="userService" ref="userService"/>
        <property name="txManager" ref="txManager"/>
    </bean>
    <!--被代理对象-->
    <bean  id="userService" class="com.test.class01_static.service.impl.UserServiceImpl">
         <property name="userDao" ref="userDao"/>
    </bean>



</beans>

public class UserDaoImpl implements IUserDao {
    
    public void save() {
        System.out.println("保存成功!!!!!!!!!!");
    }

    
    public void update() {
        System.out.println("更新成功~~~~~~~~~");
    }
}

public class UserServiceImplProxy implements IUserService {
    /**
     * 静态代理的特点：
     * 指在程序运行之前就存在代理对象的字节码文件（本文件）
     * 一个代理类只能代理一种类型
     * 实现了责任分离的目标（事务的开启、提交、回滚与业务分离）
     * 静态代理因为多了代理层，从而提升了维护成本
     */

    @Setter
    private IUserService userService;
    @Setter
    private TransactionManager txManager;


    public void save() {
        try{
            //开启事务
            txManager.begin();
            //处理事务
            userService.save();
            //提交事务
            txManager.commit();
        }catch (Exception e){
            //回滚事务
            txManager.rollback();
        }
    }


    public void update() {
        try{
            //开启事务
            txManager.begin();
            //处理事务
            userService.update();
            //提交事务
            txManager.commit();
        }catch (Exception e){
            //回滚事务
            txManager.rollback();
        }
    }
}

public class UserServiceImpl implements IUserService {
    @Setter
    private IUserDao userDao;

    public void save() {
        userDao.save();
    }


    public void update() {
        userDao.update();
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {
    @Autowired
    @Qualifier("proxy")
    //因为bean中有两个服务层对象，所以利用别名的方式区分代理和服务层对象
    //也可直接命名IUserService proxy 效果相同
    private IUserService userService;

    @Test
    public void testSave() throws Exception {
        //因为使用的是proxy代理对象，所以使用的是代理类的方法
        userService.save();
    }

    @Test
    public void testUpdate() throws Exception {
        userService.update();
    }
}

JDK动态代理

1、在程序运行之前是没有字节码文件的，在程序运行时由JVM通过反射机制动态的创建出代理对象的字节码。代理对象和真实对象的关系是在程序运行时才确定的。

2、JDK动态代理API分析:

1、java.lang.reflect.Proxy 类:
Java 动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。 
主要方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler hanlder)
方法职责：为指定类加载器、一组接口及调用处理器生成动态代理类实例 
参数:
   loader        :类加载器
   interfaces        :目标对象实现的接口
   hanlder        :代理执行处理器

返回:动态生成的代理对象
2、java.lang.reflect.InvocationHandler接口:
public Object invoke(Object proxy, Method method, Object[] args)
方法职责：负责集中处理动态代理类上的所有方法调用
参数: 
    proxy    :生成的代理对象
    method    :当前调用的真实方法对象
    args    :当前调用方法的实参

返回: 真实方法的返回结果
------------------------------------------------------------------------------------
jdk动态代理操作步骤 
①　实现InvocationHandler接口，创建自己增强代码的处理器。
②　给Proxy类提供ClassLoader对象和代理接口类型数组，创建动态代理对象。
③　在处理器中实现增强操作。

3.步骤

　　1、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--事务管理器-->
    <bean id="manager" class="com.test.class02_JDKProxy.tx.TransactionManager"/>

    <!--JDK动态代理-->
    <bean id="proxy" class="com.test.class02_JDKProxy.proxy.JDKProxy">
        <property name="txManager" ref="manager"/>
        <property name="target" ref="userService"/>
    </bean>

    <!--CGlib动态代理-->
    <bean id="cglibProxy" class="com.test.class02_JDKProxy.cglib.CglibProxy">
        <property name="target" ref="userService"/>
        <property name="txManager" ref="manager"/>
    </bean>


    <bean id="userService" class="com.test.class02_JDKProxy.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

    <bean id="userDao" class="com.test.class02_JDKProxy.dao.impl.UserDaoImpl"/>

</beans>

　　其余的代码和上面一样

　　2、获取代理对象，实现接口成为代理类，实现接口的方法

public class JDKProxy implements InvocationHandler {
    @Setter
    private Object target;
    @Setter
    private TransactionManager txManager;

    //java.lang.reflect.Proxy是java所有动态代理类的父类
    public Object getProxy(){
        /**Proxy.newProxyInstance提供了一组静态方法为一组接口动态的生成代理类及对象
         * 第一个参数：类加载器
         * 第二个参数：目标对象实现的接口的字节码数据对象
         * 第三个参数：实现了InvocationHandler接口的类的对象（代理类）
         *          （本类可实现此接口，成为代理类）
         */
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        /**
         * proxy：代理对象
         * method：当前调用的真实方法，利用反射使用方法
         *        方法的使用,方法.invoke(对象名，参数)
         * args：当前调用方法的实参
         */
        try {
            //开启事务
            txManager.begin();
            //处理事务
            method.invoke(target,args);
            //提交事务
            txManager.commit();

        }catch (Exception e){
            //回滚事务
            txManager.rollback();
        }finally {
            //释放资源
            txManager.destroy();
        }
        return null;
    }
}

　　3、测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {
    @Autowired
    private JDKProxy proxy;
    @Autowired
    private CglibProxy cglibProxy;

    @Test
    public void testSave() throws Exception {
        IUserService service = (IUserService)this.proxy.getProxy();
        System.out.println(service.getClass());
        service.save();
    }


    @Test
    public void testUpdate() throws Exception {
        IUserService service = (IUserService)this.proxy.getProxy();
        service.update();
    }

    @Test
    public void testSave2() throws Exception {
        UserServiceImpl service = (UserServiceImpl)cglibProxy.getProxy();
        service.save();
    }

    @Test
    public void testUpdate2() throws Exception {
        UserServiceImpl service = (UserServiceImpl)cglibProxy.getProxy();
        service.update();
    }
}

4、原理

 

 

 5、JDK动态代理:

　　1.代理的对象必须要实现接口

　　2.需要为每个对象创建代理对象;

　　3.动态代理的最小单位是类(类中所有的方法都会被代理);

6、JDK动态代理总结：

　　1.JAVA动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口这两个来完成的。

　　2.要使用JDK动态代理，必须要定义接口。

　　3.JDK动态代理将会拦截所有public的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。

　　4.如果只想拦截一部分方法，可以在invoke方法中对要执行的方法名进行判断

7、CGLib针对没有接口的类的代理，和动态代理的区别是获取代理对象的方法不一样，其余一样

public class CglibProxy implements InvocationHandler {
    @Setter
    private Object target;
    @Setter
    private TransactionManager txManager;

    public Object getProxy(){
        Enhancer enhancer = new Enhancer();//增强类
        enhancer.setSuperclass(UserServiceImpl.class);//对哪个父类增强
        //设置如何增强（写实现了InvocationHandler的接口的类，也就是代理类）
        //这里本类实现了此接口，为代理类
        enhancer.setCallback(this);
        return enhancer.create();//创建并返回代理对象
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            //开启事务
            txManager.begin();
            //处理事务
            method.invoke(target,args);
            //提交事务
            txManager.commit();

        }catch (Exception e){
            //回滚事务
            txManager.rollback();
        }finally {
            //释放资源
            txManager.destroy();
        }
        return null;
    }
}

8、CGLib代理总结

　　1.CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。

　　2.要求类不能是final的，要拦截的方法要是非final、非static、非private的。

　　3.动态代理的最小单位是类(所有类中的方法都会被处理);

9、在Spring中：

 

　　1.若目标对象实现了若干接口，Spring就会使用JDK动态代理。

 

　　2.若目标对象没有实现任何接口，Spring就使用CGLIB库生成目标对象的子类。

 

　　3.对接口创建代理优于对类创建代理，因为会产生更加松耦合的系统，也更符合面向接口编程规范。