1.场景问题解决
1.1 场景描述
监控糖果机：地点、糖果库存和当前状态
1.2 OO设计
1.3 需求变动
1.4 带来问题
2.用设计模式改进
2.1 分析
远程代理：远程对象的本地代表，通过它可以让远程对象当本地对象来调用。
远程代理通过网络和真正的远程对象沟通信息
2.2 Java RMI
2.2.1 定义
RMI远程方法调用是计算机之间通过网络实现对象调用的一种通讯机制。
使用这种机制，一台计算机上的对象可以调用另外 一台计算机上的对象来获取远程数据。
在过去，TCP/IP通讯是远程通讯的主要手段，面向过程的开发。
而RPC使程序员更容易地调用远程程序，但在面对复杂的信息传讯时，RPC依然未能很好的支持
RMI被设计成一种面向对象开发方式，允许程序员使用远程对象来实现通信
2.2.2 实现步骤
制作远程接口：接口文件
远程接口的实现：Service文件
RMI服务端注册，开启服务
RMI代理端通过RMI查询到服务端，建立联系，通过接口调用远程方法
2.2.3 源码
- MyRemote,MyRemoteImpl,MyRemoteClient
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface MyRemote extends Remote{
public String sayHello() throws RemoteException;
}
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote{
protected MyRemoteImpl() throws RemoteException {
super();
}
@Override
public String sayHello() throws RemoteException {
return "Hello World!";
}
public static void main(String[] args) {
try {
MyRemote service=new MyRemoteImpl();
// LocateRegistry.createRegistry(6600);
Naming.rebind("rmi://127.0.0.1:6600/RemoteHello", service);
} catch (Exception e) {
e.printStackTrace();
System.out.println( e.toString());
}
}
}
import java.rmi.Naming;
public class MyRemoteClient {
public static void main(String[] args) {
new MyRemoteClient().go();
}
public void go(){
try {
MyRemote service=(MyRemote)Naming.lookup("rmi://127.0.0.1:6600/RemoteHello");
String s=service.sayHello();
System.out.println(s);
} catch (Exception e) {
e.printStackTrace();
}
}
}
import java.rmi.Naming;
public class RemoteMainTest {
public static void main(String[] args) {
try {
CandyMachine service = new CandyMachine("test1", 7);
// LocateRegistry.createRegistry(6602);
Naming.rebind("rmi://127.0.0.1:6602/test1", service);
service.insertCoin();
service = new CandyMachine("test2", 5);
Naming.rebind("rmi://127.0.0.1:6602/test2", service);
} catch (Exception e) {
e.printStackTrace();
System.out.println(e.toString());
}
}
}
2.3 重新设计
3.设计模式总结
3.1 定义
代理模式：为一个对象提供一个替身，以控制对这个对象的访问(简单说即是在不改变源码的情况下，实现对目标对象的功能扩展。)
被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
代理模式有很多变体，都是为了控制与管理对象访问
3.2 常见的代理模式
- 虚拟代理
虚拟代理为创建开销大的对象提供代理服务。
真正的对象在创建前和创建中时，由虚拟代理来扮演替身 - 动态代理
运行时动态的创建代理类，并将方法调用转发到指定类
看一个找对象项目 - PersonBean,PersonBeanImpl,OwnerInvocationHandler,NonOwnerInvocationHandler,MatchService
public interface PersonBean {
String getName();
String getGender();
String getInterests();
int getHotOrNotRating();
void setName(String name);
void setGender(String gender);
void setInterests(String interests);
void setHotOrNotRating(int rating);
}
public class PersonBeanImpl implements PersonBean{
String name;
String gender;
String interests;
int rating;
int ratingcount=0;
@Override
public String getName() {
return name;
}
@Override
public String getGender() {
return gender;
}
@Override
public String getInterests() {
return interests;
}
@Override
public int getHotOrNotRating() {
if(ratingcount==0) return 0;
return (rating/ratingcount);
}
@Override
public void setName(String name) {
this.name=name;
}
@Override
public void setGender(String gender) {
this.gender=gender;
}
@Override
public void setInterests(String interests) {
this.interests=interests;
}
@Override
public void setHotOrNotRating(int rating) {
this.rating=rating;
ratingcount++;
}
}
// 自有代理
public class OwnerInvocationHandler implements InvocationHandler{
PersonBean person;
public OwnerInvocationHandler(PersonBean person){
this.person=person;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().startsWith("get")){
return method.invoke(person,args);
}else if(method.getName().equals("setHotOrNotRating")){
return new IllegalAccessException();
}else if(method.getName().startsWith("set")){
return method.invoke(person,args);
}
return null;
}
}
// 权限受限代理
public class NonOwnerInvocationHandler implements InvocationHandler{
PersonBean person;
public NonOwnerInvocationHandler(PersonBean person){
this.person=person;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().startsWith("get")){
return method.invoke(person,args);
}else if(method.getName().equals("setHotOrNotRating")){
return method.invoke(person,args);
}else if(method.getName().startsWith("set")){
return new IllegalAccessException();
}
return null;
}
}
public class MatchService {
public MatchService() {
PersonBean joe = getPersonInfo("joe", "male", "running");
PersonBean OwnerProxy = getOwnerProxy(joe);
System.out.println("Name is " + OwnerProxy.getName());
System.out.println("Interests is " + OwnerProxy.getInterests());
OwnerProxy.setInterests("Bowling");
System.out.println("Interests are " + OwnerProxy.getInterests());
OwnerProxy.setHotOrNotRating(50);
System.out.println("Rating is " + OwnerProxy.getHotOrNotRating());
OwnerProxy.setHotOrNotRating(40);
System.out.println("Rating is " + OwnerProxy.getHotOrNotRating());
System.out.println("**************");
PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
System.out.println("Name is " + nonOwnerProxy.getName());
System.out.println("Interests are " + nonOwnerProxy.getInterests());
nonOwnerProxy.setInterests("haha");
System.out.println("Interests are " + nonOwnerProxy.getInterests());
nonOwnerProxy.setHotOrNotRating(60);
System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
}
PersonBean getPersonInfo(String name, String gender, String interests) {
PersonBean person = new PersonBeanImpl();
person.setName(name);
person.setGender(gender);
person.setInterests(interests);
return person;
}
PersonBean getOwnerProxy(PersonBean person) {
return (PersonBean) Proxy.newProxyInstance(person.getClass()
.getClassLoader(), person.getClass().getInterfaces(),
new OwnerInvocationHandler(person));
}
PersonBean getNonOwnerProxy(PersonBean person) {
return (PersonBean) Proxy.newProxyInstance(person.getClass()
.getClassLoader(), person.getClass().getInterfaces(),
new NonOwnerInvocationHandler(person));
}
}
- 保护代理
类似房屋中介 - 几种变体
-
- 防火墙代理
-
- 缓存代理
-
- 智能引用代理
-
- 同步代理
-
- 写入时复制代理
3.3 分析思路
3.4 其它设计模式区别
装饰者模式: 装饰以后会添加新功能
代理模式目的是对目标对象访问的控制和管理
4. 设计模式使用场景及注意
4.1 java代理模式-静态代理
4.1.1 源码
- ISinger,Singer,SingerProxy,TestStaticproxy
public interface ISinger {
void sing();
}
/**
* 目标对象实现了某一接口
*/
public class Singer implements ISinger{
public void sing(){
System.out.println("唱一首歌");
}
}
/**
* 代理对象和目标对象实现相同的接口
*/
public class SingerProxy implements ISinger{
// 接收目标对象，以便调用sing方法
private ISinger target;
public SingerProxy(ISinger target){
this.target=target;
}
// 对目标对象的sing方法进行功能扩展
public void sing() {
System.out.println("向观众问好");
target.sing();
System.out.println("谢谢大家");
}
}
public class TestStaticproxy {
public static void main(String[] args) {
//目标对象
ISinger target = new Singer();
//代理对象
ISinger proxy = new SingerProxy(target);
//执行的是代理的方法
proxy.sing();
}
}
4.1.2 总结
总结：其实这里做的事情无非就是，创建一个代理类SingerProxy，继承了ISinger接口并实现了其中的方法。只不过这种实现特意包含了目标对象的方法，正是这种特征使得看起来像是“扩展”了目标对象的方法。假使代理对象中只是简单地对sing方法做了另一种实现而没有包含目标对象的方法，也就不能算作代理模式了。所以这里的包含是关键。
缺点：这种实现方式很直观也很简单，但其缺点是代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。如果能在运行时动态地写出代理对象，不但减少了一大批代理类的代码，也少了不断维护的烦恼，不过运行时的效率必定受到影响。这种方式就是接下来的动态代理。
4.2 java代理模式-动态代理
4.2.1 源码
- ISinger,Singer,TestDynamicproxy
public interface ISinger {
void sing();
}
public class Singer implements ISinger {
public void sing(){
System.out.println("唱一首歌");
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class TestDynamicproxy {
public static void main(String[] args) {
Singer target = new Singer();
ISinger proxy = (ISinger) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("向观众问好");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("谢谢大家");
return returnValue;
}
});
proxy.sing();
}
}
4.2.2 总结
这回直接上测试，由于java底层封装了实现细节（之后会详细讲），所以代码非常简单，格式也基本上固定。
调用Proxy类的静态方法newProxyInstance即可，该方法会返回代理类对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
接收的三个参数依次为:
ClassLoader loader：指定当前目标对象使用类加载器，写法固定
Class<?>[] interfaces：目标对象实现的接口的类型，写法固定
InvocationHandler h：事件处理接口，需传入一个实现类，一般直接使用匿名内部类
总结：以上代码只有标黄的部分是需要自己写出，其余部分全都是固定代码。由于java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便，具体的底层原理将会在下一小节说明。
缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，加入没有，则可以使用Cglib代理。
4.3 java代理模式-Cglib代理
4.3.1 源码
- Singer,ProxyFactory,TestCglibproxy
import course.designpattern.agent13.common.staticproxy.ISinger;
public class Singer implements ISinger{
public void sing(){
System.out.println("唱一首歌");
}
}
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* Cglib子类代理工厂
*/
public class ProxyFactory implements MethodInterceptor {
// 维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("向观众问好");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("谢谢大家");
return returnValue;
}
}
public class TestCglibproxy {
public static void main(String[] args){
//目标对象
Singer target = new Singer();
//代理对象
Singer proxy = (Singer)new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.sing();
}
}
需要引入cglib的jar文件，由于Spring的核心包中已经包括了Cglib功能，所以也可以直接引入spring-core-3.2.5.jar
目标类不能为final
目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法
4.4 总结
在Spring的AOP编程中：
如果加入容器的目标对象有实现接口，用JDK代理
如果目标对象没有实现接口，用Cglib代理
5.参考文章
内容总计于HeadFirst设计模式及相关视频
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
