代理模式-P19

静态代理：

创建项目：

Rent

package com.Li.demo01;
 
//租房
public interface Rent {
    public void rent();
}

 Proxy：

package com.Li.demo01;
//中介（负责找房东）
public class Proxy implements Rent{
    //
    private Host host;
 
    public Proxy() {
    }
 
    public Proxy(Host host) {
        this.host = host;
    }
 
    @Override
    public void rent() {
        host.rent();
    }
}

Host：

package com.Li.demo01;
 
//房东
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

Client：

package com.Li.demo01;
 
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

由于中介也需要房东，所以需要在此之前new一个房东。

你可能认为有没有效果都一样，但是在这个过程中，中介可以有自己的属性和方法。增加自己想要的内容。

修改之后

Proxy：（增加了自己的特有方法）

package com.Li.demo01;
//中介（负责找房东）
public class Proxy implements Rent{
    //
    private Host host;
 
    public Proxy() {
    }
 
    public Proxy(Host host) {
        this.host = host;
    }
 
    @Override
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
 
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
 
    //签合同
    public void hetong(){
        System.out.println("签租赁合同");
    }
 
    //收费
    public void fare(){
        System.out.println("收中介费");
    }
 
}

此时就已经经过了中介之手，租到房了。

 

---

拓展：

新建demo02

UserService：

package com.Li.demo02;
 
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

UserServiceImpl：

package com.Li.demo02;
 
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }
 
    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }
 
    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }
 
    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

UserServiceProxy：（代理类）（重点！）========相当于复制了一份原本的内容，这样操作出错的时候也不会影响原本内容。

package com.Li.demo02;
 
public class UserServiceProxy implements UserService{
 
    //相当于在Proxy里面调取了UserServiceImpl
    private UserServiceImpl userService;
 
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
 
    @Override
    public void add() {
        log("add");
        userService.add();
    }
 
    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }
 
    @Override
    public void update() {
        log("update");
        userService.update();
    }
 
    @Override
    public void query() {
        log("query");
        userService.query();
    }
 
    //日志方法
    public void log(String msg){
        System.out.println("[debug] 使用了"+msg+"方法");
    }
}

Client：（测试）

package com.Li.demo02;
 
public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
 
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);//中介（proxy）代理userService
 
        proxy.add();
    }
}

测试结果：

AOP就是横切进去，用来完善之前的业务。

 

---

动态代理：

· 动态代理和静态代理角色一样
· 动态代理的代理类是动态生成的，不是我们直接写好的！
· 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
        ·基于接口 — JDK动态代理【我们在这里使用】
        ·基于类：cglib
        ·java字节码实现：javassist
需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

Rent（接口）

package com.Li.demo03;
 
//租房
public interface Rent {
    public void rent();
}

Host

package com.Li.demo03;
 
//房东
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

ProxyInvocationHandler（核心）（就相当于中介）

package com.Li.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;
    }
 
 
    //生成得到代理类
    //(返回三个参数：用哪个类加载器去加载代理对象（中介），被代理的对象（房东），谁来进行这种new操作(运用invoke来操作)生成中介（也就是谁来生成中介）)
    //通过本程序的类加载器，来加载需要被代理的角色，生成代理类（三个参数的解释）
    //一般只需要修改中间的参数就可以了
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }
 
    //处理代理实例，并返回结果（真正的中介，上面的中介相当于是复制之前的内容，这个相当于可以在复制内容上面修改）
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 
        seeHouse();
        //动态代理的本质，就是使用反射机制实现！
        Object invoke = method.invoke(rent, args);
        fare();
 
        return invoke;
    }
 
 
    public void seeHouse(){
        System.out.println("中介看房子");
    }
 
    public void fare(){
        System.out.println("收中介费");
    }
 
 
 
 
 
 
 
}

Client：（测试）

package com.Li.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();
 
    }
}