代理模式
代理模是SpringAOP的底层！
代理模式分为：
- 静态模式
- 动态代理
1、静态代理
首先我们先进行角色分析
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
代码实现
1、接口
package com.star.demo01;
public interface Rent {
public void rent();
}
2、真实角色
package com.star.demo01;
public class Host implements Rent {
public void rent() {
System.out.println("房东要出租房子！");
}
}
3、代理角色
package com.star.demo01;
public class Proxy {
private Host host;
public Proxy() {
this.host = new Host();
}
//租房
public void getHost() {
host.rent();
}
//看房
public void seeHouse(){
System.out.println("中介带你看房！");
}
//收中介费
public void getMoney(){
System.out.println("收中介费！");
}
//合同
public void heTong(){
System.out.println("签合同");
}
}
4、客户
package com.star.demo01;
public class Client {
public static void main(String[] args) {
Proxy proxy = new Proxy();
//不用面对房东，直接找中介租房即可！
proxy.getHost();
//代理角色会有一些附属操作！
proxy.seeHouse();
proxy.getMoney();
proxy.heTong();
}
}
结果：
代理模式的好处：
- 可以使真实角色更加纯粹！不用去关注一些公共的业务；
- 公共也就是交给代理角色，实现了业务的分工；
- 公共业务放发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率降低！
再次代码实现
1、接口
package com.star.demo02;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
2、实现类
package com.star.demo02;
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户！");
}
public void delete() {
System.out.println("删除了一个用户！");
}
public void update() {
System.out.println("修改了一个用户！");
}
public void query() {
System.out.println("查找了一个用户！");
}
}
3、当我们要给方法添加日志时就需要一个代理类
这样不会改变原有的代码，只是新增了一个代理类。
符合面向对象的原则！
package com.star.demo02;
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void getUserService() {
this.userService = new UserServiceImpl();
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
//日志方法
public void log(String msg){
System.out.println("【Debug】使用了"+msg+"方法");
}
}
4、客户
package com.star.demo02;
public class Client {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy proxy = new UserServiceProxy();
proxy.getUserService();
proxy.add();
}
}
结果：
2、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类时动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理和基于类的动态代理
- 基于接口：JDK 动态代理【我们在这里使用】
- 基于类：cglib
- Java字节码实现：JAVAssit
首先需要了解两个类：
- Proxy：代理
- InvocationHandler：调用处理程序
动态代理实现租房
1、接口
package com.star.demo03;
public interface Rent {
public void rent();
}
2、真实角色
package com.star.demo03;
public class Host implements Rent {
public void rent() {
System.out.println("房东要出租房子！");
}
}
3、处理程序
package com.star.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//我们用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到动态代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结束
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质，就是使用反射机制实现！
Object invoke = method.invoke(rent, args);
return invoke;
}
}
4、客户
package com.star.demo03;
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理角色
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象！
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy();//动态生成的代理类，我们并没有写
proxy.rent();
}
}
结果：
动态代理实现增删改查
1、接口
package com.star.demo04;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
2、实现类
package com.star.demo04;
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户！");
}
public void delete() {
System.out.println("删除了一个用户！");
}
public void update() {
System.out.println("修改了一个用户！");
}
public void query() {
System.out.println("查找了一个用户！");
}
}
3、处理程序
package com.star.demo04;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//使用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结束
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//这里添加日志方法
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
//日志方法
public void log(String msg){
System.out.println("执行了"+msg+"方法！");
}
}
4、客户
package com.star.demo04;
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService) pih.getProxy();
proxy.add();
}
}
结果：
动态代理的好处：
- 可以使真实角色的操作更加纯粹，不用去关注一些公共业务；
- 公共业务就交给代理角色，实现了业务的发工；
- 公共业务发生扩展的时候，方便集中管理；
- 一个动态代理代理的是一个接口，一般就是对应的一类业务；
- 一个动态代理类可以代理多个类，只要实现了同一个接口即可！