SpringAOP基础 - 代理设计模式_springaop基于什么设计模式-CSDN博客

本文链接：https://blog.csdn.net/acsdds/article/details/109256562

SpringAOP基础 - 代理设计模式

改造过后的EasyMall的问题
改造过后的EasyMall成功解决了耦合的问题，但是在很多地方仍然存在非该层应该实现的功能，造成了无法“高内聚”的现象，同时存在大量存在重复代码，开发效率低下。
此时可以通过代理设计模式，将这部分代码提取到代理者中，简化层中的代码。

@Service
public class UserServiceImpl implements UserService {
        @Autowired
        private UserDao userDao;   
 
        @Override
        public void registUser(User user) {
                try {
                        System.out.println("校验权限。。。");
                        System.out.println("开启事务。。。");
                        System.out.println("记录日志。。。");
                        userDao.addUser(user);
                        System.out.println("提交事务。。。");
                } catch (Exception e) {
                        System.out.println("回滚事务");
                        e.printStackTrace();
                }
        }
 
        @Override
        public void upToVIP(User user) {
                try {
                        System.out.println("校验权限。。。");
                        System.out.println("开启事务。。。");
                        System.out.println("记录日志。。。");
                        userDao.updateUser(user);
                        System.out.println("提交事务。。。");
                } catch (Exception e) {
                        System.out.println("回滚事务");
                        e.printStackTrace();
                }
                
        }
 
        @Override
        public void removeUser(User user) {
                try {
                        System.out.println("校验权限。。。");
                        System.out.println("开启事务。。。");
                        System.out.println("记录日志。。。");
                        userDao.deleteUser(user.getId());
                        System.out.println("提交事务。。。");
                } catch (Exception e) {
                        System.out.println("回滚事务");
                        e.printStackTrace();
                }
        }
}

静态代理模式

静态代理实现：

package cn.tedu.staticproxy;
public interface SJSkill {
        public void 吃();
        public void 唱歌();
}
 
package cn.tedu.staticproxy;
public class FBB implements SJSkill{
        public void 吃(){
                System.out.println("fbb吃饭。。。");
        }
        public void 唱歌(){
                System.out.println("fbb唱歌。。。");
        }
}
 
package cn.tedu.staticproxy;
public class JJRStaticProxy implements SJSkill{
 
        private FBB fbb = new FBB();
        
        @Override
        public void 吃() {
                System.out.println("权限认证：你谁啊？？？？");
                fbb.吃();
                System.out.println("记录日志：等我，我记一下来访记录");
        }
 
        @Override
        public void 唱歌() {
                System.out.println("权限认证：你谁啊？？？？");
                fbb.唱歌();
                System.out.println("记录日志：等我，我记一下来访记录");
        }
 
}
 
package cn.tedu.staticproxy;
import org.junit.Test;
public class StaticProxyTest {
        @Test
        public void test01(){
                JJRStaticProxy jjr = new JJRStaticProxy();
                jjr.吃();
                jjr.唱歌();
        }
}

静态代理设计模式特点：
优点：结构清晰易于理解
缺点：如果被代理者有多个方法，则代理者也需要开发多个方法，其中往往存在大量重复代码，仍然存在代码重复。

静态代理设计模式解决了软件分层过程中额外的功能代码侵入模块的问题，将额外的功能代码提取到了代理者中进行，但是静态代理实现的代理者中存在大量重复的代码，并没有解决代码重复问题。所以在真正开发中–包括spring的底层，基本不会使用静态代理。

动态代理 - jdk内置的动态代理
在jdk中提供了动态代理实现的工具类，直接使用该工具类就可以创建出代理者，并且可以通过内置的回调函数指定代理在工作时的执行逻辑，从而实现基于jdk原生api的动态代理机制。

java.lang.reflect
类 Proxy
java.lang.Object

static Object
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

案例：

package cn.tedu.javaproxy;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
import org.junit.Test;
 
public class JavaProxyTest {
        @Test
        public void test01(){
        
                //被代理者
                final FBB fbb = new FBB();
                
                //java动态代理方式 生成fbb的代理者
                /**
                 * classLoader:用来生成代理者类的类加载器，通常可以传入被代理者类的类加载器
                 * interfaces: 要求生成的代理者实现的接口们，通常就是实现和被代理者相同的接口，保证具有和被代理者相同的方法
                 * invocationHandler: 用来设定回调函数的回调接口，使用者需要写一个类实现此接口，从而实现其中的invoke方法，
                 * 在其中编写代码处理代理者调用方法时的回调过程，通常在这里调用真正对象身上的方法，并且在方法之前或之后做额外操作。
                 */
                SJSkill proxy = (SJSkill) Proxy.newProxyInstance(
                         FBB.class.getClassLoader()
                         ,FBB.class.getInterfaces()
                           ,new InvocationHandler() {
                              @Override
                            public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
                                   if("拍电影".equals(method.getName())){
                                          System.out.println("不好意思，给多少钱不拍了~~");
                                          return null;
                                    }else{
                                              System.out.println("检验权限。。。。");
                                             Object returnObj = method.invoke(fbb, args);
                                              System.out.println("记录日志。。。。");
                                              return returnObj;
                                                }
                                        }
                                });
                //从此之后，不允许直接调用被代理者身上的方法，而是要通过代理者来调用
                //fbb.吃();
                //fbb.唱歌();
                proxy.吃();
                proxy.唱歌();
                proxy.拍电影();
        }
}

java动态代理的原理图：
在这里插入图片描述
java动态代理的特点：

优点：不需要像静态代理一样被代理方法都要实现一遍，而只需要在回调函数中进行处理就可以了，重复代码只需编写一次。
缺点：java的动态代理是通过代理者实现和被代理者相同的接口来保证两者具有相同的方法的，如果被代理者想要被代理的方法不属于任何接口，则生成的代理者自然无法具有这个方法，也就无法实现对该方法的代理。
所以java的动态代理机制是基于接口进行的，受制于要代理的方法是否有接口的支持。

动态代理 - 第三方包cglib实现的动态代理
CGLIB是第三方提供的动态代理的实现工具，不管有没有接口都可以实现动态代理。
CGLIB实现动态代理的原理是生成的动态代理是被代理者的子类，所以代理者具有和父类即被代理者相同的方法，从而实现代理，这种方式基于继承，不再受制于接口。

a.导入CGLIB相关包
之前导入的spring包中就包含了CGLIB

spring-core-3.2.3.RELEASE.jar

b.开发CGLIB程序
案例：

package cn.tedu.cglibproxy;
 
import java.lang.reflect.Method;
 
import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
 
public class CglibProxyTest {
        @Test
        public void test01(){
                final FBB fbb = new FBB();
                
                //增强器
                Enhancer enhancer = new Enhancer();
               
                //设定接口 -- 此方法要求生成的动态代理额外实现指定接口们 ，单cglib动态代理不是靠接口实现的，所以可以不设置
                enhancer.setInterfaces(fbb.getClass().getInterfaces());
                
                //设定父类 -- 此处要传入被代理者的类，cglib是通过集成被代理者的类来持有和被代理者相同的方法的，此方法必须设置
                enhancer.setSuperclass(fbb.getClass());
                
                //设定回调函数 -- 为增强器设定回调函数，之后通过增强器生成的代理对象调用任何方法都会走到此回调函数中，实现调用真正被代理对象的方法的效果
                enhancer.setCallback(new MethodInterceptor() {
                        @Override
                        public Object intercept(Object proxy, Method method, Object[] args,
                                        MethodProxy methodProxy) throws Throwable {
                                if("拍电影".equals(method.getName())){
                                        System.out.println("对不起，不拍了~~~");
                                        return null;
                                }else{
                                        System.out.println("检查权限。。。");
                                        Object returnObj = method.invoke(fbb, args);
                                        System.out.println("记录日志。。。");
                                        return returnObj;
                                }
                        }
                });
                
                //生成代理对象
                FBB proxy = (FBB) enhancer.create();
                proxy.吃();
                proxy.唱歌();
                proxy.拍电影();
        }
}

CGLIB动态代理原理图：

在这里插入图片描述
CGLIB动态代理的特点：

优点：无论是否有接口都可以实现动态代理，使用场景基本不受限

缺点：第三方提供的动态代理机制，不是原生的，需要导入第三方开发包才可以使用。

使用代理改造EasyMall
使用代理改造EasyMall，将功能代码提取到代理者中，实现“高内聚”的效果。

a.静态代理

package cn.tedu.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
 
import cn.tedu.domain.User;
 
@Service("userService")
public class StaticProxyUserServiceImpl implements UserService{
 
@Autowired
@Qualifier("userServiceImpl")
private UserService userService = null;
 
@Override
public void addUser(User user) {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println("addUser访问开始.."+System.currentTimeMillis());
 
userService.addUser(user);
 
System.out.println("addUser访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
}
 
@Override
public User loginUser(String username, String password) {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println("loginUser访问开始.."+System.currentTimeMillis());
 
User user = userService.loginUser(username, password);
 
System.out.println("loginUser访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
return user;        
}
 
@Override
public void logoutUser() {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println("logoutUser访问开始.."+System.currentTimeMillis());
 
userService.logoutUser();
 
System.out.println("logoutUser访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
}
 
@Override
public void updateUser() {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println("updateUser访问开始.."+System.currentTimeMillis());
 
userService.updateUser();
 
System.out.println("updateUser访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
}
 
}

b.java动态代理

package cn.tedu.service;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
 
@Component
public class JavaProxyUserServiceImplFactory {
@Autowired
@Qualifier("userServiceImpl")
private UserService userService = null;
 
@Bean(name="userService")
public UserService getProxy() {
UserService proxy = (UserService) Proxy.newProxyInstance(
userService.getClass().getClassLoader(), 
userService.getClass().getInterfaces(), 
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(Arrays.asList(UserService.class.getMethods()).contains(method)) {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println(method.getName()+"访问开始.."+System.currentTimeMillis());
Object obj = method.invoke(userService, args);
System.out.println(method.getName()+"访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
return obj;
}else {
return method.invoke(userService, args);
}
                         }
                   }
        );
        return proxy;
}
}

c.cglib动态代理

package cn.tedu.service;
 
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
 
@Component
public class CglibProxyUserServiceImplFactory {
 
@Autowired
@Qualifier("userServiceImpl")
private UserService userService = null;
 
@Bean(name="userService")
public UserService getProxy() {
//1.创建增强器
Enhancer enhancer = new Enhancer();
//2.配置接口
enhancer.setInterfaces(userService.getClass().getInterfaces());
//3.配置父类
enhancer.setSuperclass(userService.getClass());
//4.配置回调函数
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy mp) throws Throwable {
List<String> mlist = new ArrayList<String>();
for(Method m : UserService.class.getMethods()) {
mlist.add(m.getName());
}
if(mlist.contains(method.getName())) {
System.out.println("开启事务...");
System.out.println("检查权限...");
System.out.println(method.getName()+"访问开始.."+System.currentTimeMillis());
 
Object obj = method.invoke(userService, args);
 
System.out.println(method.getName()+"访问结束.."+System.currentTimeMillis());
System.out.println("提交/回滚事务...");
 
return obj;
}else {
return method.invoke(userService, args);
}
}
});
//5.生成代理
UserService proxy = (UserService) enhancer.create();
return proxy;
}
}