作者：程序员小王
程序员小王的博客：程序员小王的博客
扫描主页左侧二维码，加我微信 一起学习、一起进步
欢迎点赞 收藏 ⭐留言
如有编辑错误联系作者，如果有比较好的文章欢迎分享给我，我会取其精华去其糟粕
java自学的学习路线：java自学的学习路线
- 代理设计模式
- 一、结构型模式
- 二、现有开发中存在的问题
- 1、定义业务层接口
- 2、实现业务接口
- 3、Service层中包含了哪些代码？
- 4、额外功能书写在Service层中好不好？
- 5、现实生活中的解决方式
- 三、代理设计模式
- 1、概述
- 2、结构
- 1、什么是代理？ 中介
- 2、为什么需要代理？
- 3、代理的好处？
- 4、怎么开发代理对象？
- 四、静态代理
- 1、什么是静态代理
- 2、名词解释
- 3、代理开发的核心要素
- 4、编码（静态代理的开发）
- （1）UserService接口
- （2）开发静态代理类
- （3）修改目标实现类
- （4）配置静态代理类
- （5）调用代理方法
- a.开发静态代理类
- 5、静态代理存在的问题
- 五、动态代理
- 1、什么动态态代理
- 2、名词解释
- 3、搭建开发环境
- 4、JDK动态代理的开发
- (1)目标类接口
- (2)目标类
- (3)JDK动态代理代码并调用代理对象的方法测试
- 5、cglib 动态代理
- （1）目标类
- （2）动态代理代码及调用代理对象的方法测试
- 六、三种代理的对比
- 1、jdk代理和CGLIB代理的区别
- 2、动态代理和静态代理的区别？
- 七、代理模式的优缺点
- 1、代理模式的优点：
- 2、代理模式的缺点：
- 八、代理模式使用场景
- 1、远程（Remote）代理
- 2、防火墙（Firewall）代理
- 3、保护（Protect or Access）代理
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。
由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
结构型模式分为以下 7 种：
-
代理模式
-
适配器模式
-
装饰者模式
-
桥接模式
-
外观模式
-
组合模式
-
享元模式
- 问题：在JavaEE分层开发开发中，那个层次对于我们来讲最重要？
DAO ---> Service --> Controller JavaEE分层开发中，最为重要的是Service层1、定义业务层接口
public interface EmpService {
public List selectEmpByPage(int pageNumber);
public int selectTotalPage();
public void addEmp(Emp emp);
public void dropEmp(Integer id);
public void update(Emp emp);
public void plDeleteEmp(List ids);
public Emp queryEmp(Integer id);
}
2、实现业务接口
public class EmpServiceImpl implements EmpService {
@Override
public List selectEmpByPage(int pageNumber) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
//设置每页展示的页数
int rows = 3;
//设置第几页开始的起始条数
int begin = (pageNumber - 1) * rows;
List emps = mapper.selectEmpByPage(begin, rows);
MybatisUtil.close();
return emps;
}
@Override
public int selectTotalPage() {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
int i = mapper.selectTotalCount();
int rows = 3;
int page = 0;
if (i % rows == 0) {
page = i / rows;
} else {
page = i / rows + 1;
}
MybatisUtil.close();
return page;
}
@Override
public void addEmp(Emp emp) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
mapper.insertEmp(emp);
MybatisUtil.commit();
}
@Override
public void dropEmp(Integer id) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
mapper.deleteEmp(id);
MybatisUtil.commit();
}
@Override
public void update(Emp emp) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
mapper.update(emp);
MybatisUtil.commit();
}
@Override
public void plDeleteEmp(List ids) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
mapper.plDeleteEmp(ids);
MybatisUtil.commit();
}
@Override
public Emp queryEmp(Integer id) {
EmpDao mapper = (EmpDao) MybatisUtil.getMapper(EmpDao.class);
Emp emp = mapper.queryEmp(id);
MybatisUtil.close();
return emp;
}
}
3、Service层中包含了哪些代码？
Service层中 = 核心功能(几十行 上百代码) + 额外功能(附加功能) 1. 核心功能 业务运算 DAO调用 2. 额外功能 1. 不属于业务 2. 可有可无 3. 代码量很小 事务、日志、性能...
4、额外功能书写在Service层中好不好？从下图中可以看出,现有业务层中控制事务代码出现了大量的冗余,如何解决现有业务层出现的冗余问题?
Service层的调用者的角度（Controller):需要在Service层书写额外功能。
软件设计者：Service层不需要额外功能
5、现实生活中的解决方式
-
住酒店不一定需要亲自到酒店去，还可以通过微信支付下的同程艺龙来订酒店。
-
我们可以通过中介去找房子，不用直接跟房东沟通（现实生活中，我们更希望直接跟房东沟通）
-
春运买票买不到，我们可以找黄牛替我们抢票
-
想访问国外的网站，可以使用代理服务器进行访问。
单词 proxy [ˈprɑːksi] 代理
1、概述由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
Java中的代理按照代理类生成时机不同 又分为静态代理和动态代理。
-
"静态代理"代理类在编译期就生成
-
"动态代理"代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。
代理（Proxy）模式分为三种角色：
-
抽象主题（Subject）类： 通过接口或抽象类 声明真实主题和代理对象实现的业务方法。
-
真实主题（Real Subject）类： 实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
-
代理（Proxy）类 ： 提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
代理是java中的一种设计模式：代理设计模式
2、为什么需要代理？有没有代理都可以完成当前的功能，但是存在代理之后，更加专注于核心的业务功能，额外功能可以交给代理去做，实现功能的解耦合
- 生活案例：小红正在做饭，但是男朋友小李给他发消息，他如果边做饭边发消息，影响做饭的效率，他就可以口述给她的闺蜜让她闺蜜和男朋友聊天，自己认真做饭，闺蜜就是代理，"如花"就是一个接口
保证核心功能完成的前提下，同时兼顾额外功能4、怎么开发代理对象？
1、代理对象一定依赖于核心业务对象
2、代理对象和核心业务对象一定要实现相同的接口
四、静态代理 1、什么是静态代理-
静态代理：手工为某个类开发一个代理类，一个类对应一个代理类
-
通过代理类，为原始类（目标）增加额外的功能
-
好处：利于原始类(目标)的维护
-
目标类 原始类 被代理的对象
指的是 业务类 (核心功能 --> 业务运算 DAO调用) -
目标方法，原始方法
目标类(原始类)中的方法 就是目标方法(原始方法) -
额外功能 (附加功能)
日志，事务，性能，数据清洗
代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口
房东 ---> public interface UserService{
m1
m2
}
UserServiceImpl implements UserService{
m1 ---> 业务运算 DAO调用
m2
}
UserServiceProxy implements UserService
m1
m2
4、编码（静态代理的开发）
- 开发代理的原则: 代理类和目标类功能一致且实现相同的接口,同时代理类中依赖于目标类对象
public interface UserService {
void save(String name);
void delete(String id);
void update();
String findAll(String name);
String findOne(String id);
}
（2）开发静态代理类
public class UserServiceStaticProxy implements UserService{
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
@Override
public void save(String name) {
try {
System.out.println("开启事务");
userService.save(name);
System.out.println("提交事务");
}catch (Exception e){
System.out.println("回滚事务");
e.printStackTrace();
}
}
@Override
public void delete(String id) {
try {
System.out.println("开启事务");
userService.delete(id);
System.out.println("提交事务");
}catch (Exception e){
System.out.println("回滚事务");
e.printStackTrace();
}
}
@Override
public void update() {
try {
System.out.println("开启事务");
userService.update();
System.out.println("提交事务");
}catch (Exception e){
System.out.println("回滚事务");
e.printStackTrace();
}
}
@Override
public String findAll(String name) {
String all=null;
try {
System.out.println("开启事务");
all = userService.findAll(name);
System.out.println("提交事务");
}catch (Exception e){
System.out.println("回滚事务");
e.printStackTrace();
}
return all;
}
@Override
public String findOne(String id) {
String one=null;
try {
System.out.println("开启事务");
one= userService.findOne(id);
System.out.println("提交事务");
}catch (Exception e){
System.out.println("回滚事务");
e.printStackTrace();
}
return one;
}
}
（3）修改目标实现类
public class UserServiceImpl implements UserService {
@Override
public void save(String name) {
System.out.println("处理存储业务逻辑,调用DAO~~~");
}
@Override
public void delete(String id) {
System.out.println("处理删除业务逻辑,调用DAO~~~");
}
@Override
public void update() {
System.out.println("处理更新业务逻辑,调用DAO~~~");
}
@Override
public String findAll(String name) {
System.out.println("处理查找所有业务逻辑,调用DAO~~~");
return name;
}
@Override
public String findOne(String id) {
System.out.println("处理查询其中一个业务逻辑,调用DAO~~~");
return id;
}
}
（4）配置静态代理类
（5）调用代理方法
@Test
public void StaticProxyText() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("ApplicationContext.xml");
UserService userService =
(UserService) context.getBean("userServiceStaticProxy");
userService.delete("1");
}
}
a.开发静态代理类
5、静态代理存在的问题
存在问题：造成程序中存在过多的代理类，不利于后期额外功能的维护
- 静态类文件数量过多，不利于项目管理
UserServiceImpl——》 UserServiceProxy
OrderServiceImpl——》 OrderServiceProxy
- 额外功能维护性差
代理类中 额外功能修改复杂(麻烦)
五、动态代理 1、什么动态态代理-
动态代理：在程序运行的过程中，JVM动态的为某个类生成代理对象
-
概念：通过代理类为原始类(目标类)增加额外功能
-
好处：利于原始类(目标类)的维护
-
常用的动态代理技术
-
JDK 代理 : 基于接口的动态代理技术
-
cglib 代理：基于父类的动态代理技术
-
DK动态代理是利用反射机制生成一个实现代理接口的匿名类 ，在调用具体方法前调用InvokeHandler （调用处理程序的意思）来处理。
-
而cglib动态代理是利用asm开源包 ，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
-
使用场景
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库 ，spring会自动在JDK动态代理和CGLIB之间转换
- DK动态代理和CGLIB字节码生成的区别？
（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
因为是继承，所以该类或方法最好不要声明成final
2、名词解释-
目标对象：被代理的对象，称之为目标对象
-
目标方法： 核心业务对象中实现的核心方法
-
额外功能 (附加功能)
日志处理，事务，性能
4、JDK动态代理的开发 (1)目标类接口org.springframework spring-aop5.1.14.RELEASE org.aspectj aspectjrt1.8.8 org.aspectj aspectjweaver1.8.3
public interface EmpService {
public void method();
}
(2)目标类
public class EmpServiceImpl implements EmpService{
@Override
public void method() {
System.out.println("Service方法被执行了");
}
}
(3)JDK动态代理代码并调用代理对象的方法测试
@Test
public void JDKDynamicProxyTest() {
//生成动态代理对象 1、目标对象和代理对象实现相同的接口 2、代理对象一定依赖目标对象
final EmpService empService = new EmpServiceImpl();
//获取动态代理前的对象
System.out.println(empService.getClass());
// 创建代理对象
InvocationHandler invocationHandler;
//动态代理 o就是静态代理对象
EmpService empService1 = (EmpService) Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
new Class[]{EmpService.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("这是EmpServiceImpl目标对象的动态代理");
//调用目标方法 参数1：目标对象 参数2：目标方法执行时传递的参数
Object invoke = method.invoke(empService, args);
return null;
}
}
);
empService1.method();
//动态代理后的对象
System.out.println(empService1.getClass());
}
5、cglib 动态代理
需要导入两个jar（maven依赖）包，asm.jar,cglib.jar。版本自行选择·
- 所需相关依赖
asm
asm
3.3.1
cglib
cglib
3.3.0
（1）目标类
public void method() {
System.out.println("Target 运行了....");
}
（2）动态代理代码及调用代理对象的方法测试
@Test
public void CjLibTest() {
//创建目标对象
final Target target = new Target();
//创建增强器
Enhancer enhancer = new Enhancer();
// 设置父类
enhancer.setSuperclass(Target.class);
//设置回调
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("这是Target目标对象的动态代理");
//调用目标方法 参数1：目标对象 参数2：目标方法执行时传递的参数
Object invoke = method.invoke(target, objects);
return invoke;
}
});
//创建代理对象
Target t = (Target) enhancer.create();
t.method();
}
六、三种代理的对比
1、jdk代理和CGLIB代理的区别
使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的类或者方法进行代理，因为CGLib原理是动态生成被代理类的子类 。
在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率 ，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于CGLib代理 。所以如果有接口使用JDK动态代理，如果没有接口使用CGLIB代理。
2、动态代理和静态代理的区别？动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。
如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题
七、代理模式的优缺点 1、代理模式的优点：-
代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
-
代理对象可以扩展目标对象的功能；
-
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；
- 增加了系统的复杂度；
本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。
2、防火墙（Firewall）代理当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。
3、保护（Protect or Access）代理控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）