java设计模式-代理模式(实例讲解)
代理模式是java最常见的设计模式之一。spring的aop就是使用了代理模式。
一般而言，代理模式分为静态代理和动态代理两种。
作为结构类的设计模式，作用在于不修改类内部代码的情况下，对类进行拓展，是对继承机制的一种补充。
eg：下面就用户登录这个例子实现一下代理模式。
基本需求是：实现用户的登录和修改昵称功能。
上代码，先是IUser接口和user实现类
publicinterfaceIUser{
//登录
voidlogin(StringuserId,Stringpassword);
//修改昵称
voideditNickname(Stringnickname);
}
publicclassUserimplementsIUser{
privateStringnickname;
privateStringuserId;
privateStringpassword;
publicUser(StringuserId,Stringpassword){
this.userId=userId;
this.password=password;
}
@Override
publicvoidlogin(StringuserId,Stringpassword){
if(this.userId==userId&&this.password==password){
System.out.println("用户登录成功");
}
else
System.out.println("用户登录失败");
}
@Override
publicvoideditNickname(Stringnickname){
this.nickname=nickname;
System.out.println("修改昵称成功，当前用户的昵称是:"+this.nickname);
}
}
客户端类
publicclassClient{
publicstaticvoidmain(String[]args){
//不调用代理模式时
IUseruser=newUser("firs","123");
user.login("firs","123");
user.editNickname("大风");
}
还是非常简单的。可是后面产品经理跟你说，我们需要增加一个记录用户行为的功能，这下该怎么办呢？直接修改user类？不不不，用代理模式。
增加一个代理类，在代理类里面写“记录用户行为”的功能就好，不修改类，只拓展类，减少错误发生。
importjava.util.Date;
importjava.util.HashMap;
importjava.util.Map;
/**
*静态代理类必须实现接口，而且需要新创建一个类的代码出来
*@authorAdministrator
*
*/
publicclassStaticProxyimplementsIUser{
privateIUseruser;
publicStaticProxy(StringuserId,Stringpassword){
this.user=newUser(userId,password);
}
//登陆前的操作，记录当前登录的时间
voidnoteLoginInfo(String[]params,Stringopreate){
MaploginInfo=newHashMap<>();
loginInfo.put("params",params);
loginInfo.put("opreate",opreate);
loginInfo.put("opreateTime",newDate());
System.out.println("记录用户操作成功");
}
@Override
publicvoidlogin(StringuserId,Stringpassword){
noteLoginInfo(newString[]{userId,password},"login");
user.login(userId,password);
}
@Override
publicvoideditNickname(Stringnickname){
noteLoginInfo(newString[]{nickname},"editNickname");
user.editNickname(nickname);
}
}
客户端类：
publicclassClient{
publicstaticvoidmain(String[]args){
//不调用代理模式时
IUseruser=newUser("firs","123");
user.login("firs","123");
user.editNickname("大风");
System.out.println("");
System.out.println("=============调用静态代理模式后===========");
//需要实现记录用户登录和修改昵称操作的日志功能
//基于“拓展开发，修改关闭”的设计准则，我们可以用静态代理的方式
IUserproxy=newStaticProxy("firs","123");
proxy.login("firs","123");
proxy.editNickname("我还是大风");
}
这样子只需要修改客户端类和增加静态代理就可以了，完美实现。可是需求是无穷无尽的，产品经理跟你说：“我们增加了一个管理员角色，还有二级管理员”啥啥啥的一大堆角色，
这就尴尬了，每个角色都要建一个静态代理类，类爆炸了吧。不急，我们有动态代理模式。
动态代理模式在于不用自己新建代理类，你传具体的实现类（主体）给他，他就默认给你生成了一个代理类。
从本质上来说，它是利用了java的反射机制在运行时动态地生成了相应的代理类。
没有反射，就没有动态代理。
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.util.Date;
importjava.util.HashMap;
importjava.util.Map;
/**
*动态代理类不用和主体类继承同一个接口
*@authorAdministrator
*
*/
publicclassDynamicProxyimplementsInvocationHandler{
privateObjectobject;
publicDynamicProxy(StringuserId,Stringpassword,Classc){
Objectobj=null;
try{
obj=Class.forName(c.getName())
.getConstructor(String.class,String.class)
.newInstance(userId,password);
}catch(Exceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
this.object=obj;
}
//登陆前的操作，记录当前登录的时间
voidnoteLoginInfo(String[]params,Stringopreate){
MaploginInfo=newHashMap<>();
loginInfo.put("params",params);
loginInfo.put("opreate",opreate);
loginInfo.put("opreateTime",newDate());
System.out.println("记录用户操作成功");
}
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
throwsThrowable{
String[]params=newString[args.length];
for(inti=0;i
最后的客户端类：
packagecom.test.my;
importjava.lang.reflect.Proxy;
publicclassClient{
publicstaticvoidmain(String[]args){
//不调用代理模式时
IUseruser=newUser("firs","123");
user.login("firs","123");
user.editNickname("大风");
System.out.println("");
System.out.println("=============调用静态代理模式后===========");
//需要实现记录用户登录和修改昵称操作的日志功能
//基于“拓展开发，修改关闭”的设计准则，我们可以用静态代理的方式
IUserproxy=newStaticProxy("firs","123");
proxy.login("firs","123");
proxy.editNickname("我还是大风");
System.out.println("");
System.out.println("=============调用动态代理模式后===========");
DynamicProxydynamicProxy=newDynamicProxy("firs","123",Admin.class);
ClassLoadercl=Admin.class.getClassLoader();
IUseriuser=(IUser)Proxy.newProxyInstance(cl,
newClass[]{IUser.class},dynamicProxy);
iuser.login("firs","123");
iuser.editNickname("使用动态代理后的大风");
}
}
因为需求而增加的Admin类
publicclassAdminimplementsIUser{
privateStringnickname;
privateStringuserId;
privateStringpassword;
publicAdmin(StringuserId,Stringpassword){
this.userId=userId;
this.password=password;
}
@Override
publicvoidlogin(StringuserId,Stringpassword){
if(this.userId==userId&&this.password==password){
System.out.println("用户登录成功");
}
else
System.out.println("用户登录失败");
}
@Override
publicvoideditNickname(Stringnickname){
this.nickname=nickname;
System.out.println("修改昵称成功，当前用户的昵称是:"+this.nickname);
}
}
总结：
1.静态代理模式相对来说比较简单，要点在于对于每个实现类（subject主体）新建一个代理类，该代理类内有实体类（subject主体）的引用，从而可以实现对原有实现类（subject主体）的控制，包括aop的控制等。
2.静态代理是有局限性的，对于每个实体类可能都需要新建一个静态代理类，这样子可能会造成静态代理类过多的情况，所以动态代理应运而生了。
3.动态代理不局限于具体的实现类（subject主体），在其内部是用object存取实体类的引用，再利用反射获得该实体类的各种方法，从而实现对实现类（subject主体）的面向切面AOP编程控制。
4.上述的写法是JDK里的动态代理，不是特别完美，因为这种动态代理需要实体类实现至少一个接口。问题是并不是所有的类都会有接口，所以说不完美在这里。
上面都是我自己对于代理模式的理解，如有错漏，还请批评指正，多谢。
以上这篇java设计模式-代理模式(实例讲解)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。