什么是java代理模式(java中的代理是什么意思)
大家好，如果您还对什么是java代理模式不太了解，没有关系，今天就由本站为大家分享什么是java代理模式的知识，包括java中的代理是什么意思的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！
代理模式之Java动态代理
1. Overview
Java在java.lang.reflect包下，定义了自己的代理。利用这个包下的类，我们可以在运行时动态地创建一个代理类，实现一个或多个接口。并将方法的调用转发到你所指定的类。因为实际代理是在运行时创建的，所以称为：动态代理。
Proxy:完全由java产生的，而且实现了完整的subject接口。
InvocationHandler：Proxy上的任何方法调用都会被传入此类,InvocationHandler控制对RealSubject的访问。
因为Java已经帮助我们创建了Proxy类，我们需要有办法告诉Proxy类你要做什么，我们不能像以前一样把代码写入到Proxy类中，因为Proxy类不是我们实现的。那么我们应该放在哪里?放在InvocationHandler类中，InvocationHandler类是响应代理的任何调用。我们可以吧InvocationHandler想成是代理收到方法调用后，请求做实际工作的对象。
2. java.lang.reflect.InvocationHandler
被代理实例所实现的一个接口，内部只有一个invoke()方法,签名如下;
Java代码
public Object invoke(Object proxy, Method method, Object[] args)
当代理的方法被调用的时候，代理就会把这个调用转发给InvocationHandler，也就会调用它的invoke()方法。
3. java.lang.reflect.Proxy
提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类，我们经常使用的静态方式是：
Java代码
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
4.示例：
情形：自己可以查看修改姓名性别，但是不能修改rate。他人可以查看姓名，性别以及修改rate，但是不能修改姓名性别。
4.1定义一个接口:
Java代码
public interface Person{
String getName();
String getGender();
void setName(String name);
void setGender(String gender);
void setRate(int rate);
int getRate();
}
4.2定义实现Person接口类
Java代码
public class PersonImpl implements Person{
String name;
String gender;
String interests;
int rate;
public String getName(){
return name;
}
public void setName(String name){
this.name= name;
}
public String getGender(){
return gender;
}
public void setGender(String gender){
this.gender= gender;
}
public String getInterests(){
return interests;
}
public void setInterests(String interests){
this.interests= interests;
}
public int getRate(){
return rate;
}
public void setRate(int rate){
this.rate= rate;
}[nextpage]
4.3定义OwnerInvocationHandler类，表示如果为本人，则可以进行修改查看姓名性别。
Java代码
public class OwnerInvocationHandler implements InvocationHandler{
private Person personBean;
public OwnerInvocationHandler(Person personBean){
this.personBean= personBean;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws IllegalAccessException{
try{
if(method.getName().startsWith("get")){//如果方法名为get，就调用person类内的get相应方法
return method.invoke(personBean, args);
}else if(method.getName().equals("setRate")){//如果方法是setRate，则抛出异常
throw new IllegalAccessException("access deny");
}else if(method.getName().startsWith("set")){//如果为set，就调用person类内的set相应方法
return method.invoke(personBean, args);
}else{
System.out.println("non method invoke");
}
} catch(InvocationTargetException e){
e.printStackTrace();
}
return null;
}
}
4.4定义NonInvocationHandler类，表示如果不为本人，则可以进行查看姓名性别和修改rate。
Java代码
public class NonInvocationHandler implements InvocationHandler{
//
#p#副标题#e#
private Person person;
public NonInvocationHandler(Person person){
this.person= person;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable{
if(method.getName().startsWith("setRate")){
return method.invoke(person, args);
}else if(method.getName().startsWith("get")){
return method.invoke(person, args);
} else{
System.out.println("non method invoke");
return null;
}
}
}
4.5测试类MyDynamicProxy
Java代码
public class MyDynamicProxy{
public Person getOwnerPersonBeanProxy(Person person){
return(Person)Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), new OwnerInvocationHandler(person));
}
public Person getNonPersonBeanProxy(Person person){
return(Person)Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), new NonInvocationHandler(person));
}
public static void main(String[] args){
MyDynamicProxy mdp= new MyDynamicProxy();
mdp.test();
}
public void test(){
//
Person person= getPersonBeanFromDB1();
Person personProxy= getOwnerPersonBeanProxy(person);
System.out.println(personProxy.getName());
try{
personProxy.setRate(2);
} catch(Exception e){
System.out.println("can not setRate");
}
//
Person person1= getPersonBeanFromDB1();
Person personProxy2= getNonPersonBeanProxy(person1);
System.out.println(personProxy2.getName());
personProxy2.setRate(2);
System.out.println(personProxy2.getRate());
}
private Person getPersonBeanFromDB1(){
Person pb= new PersonImpl();
pb.setName("remy");
pb.setGender("girl");
pb.setRate(1);
return pb;}
输出结果:
Java代码
remy can not setRate remy 2
#p#副标题#e#
java中的代理是什么意思
代理模式在设计模式中的定义就是：为其他对象提供一种代理以控制对这个对象的访问。说白了就是，在一些情况下客户不想或者不能直接引用一个对象，而代理对象可以在客户和目标对象之间起到中介作用，去掉客户不能看到的内容和服务或者增添客户需要的额外服务。
java动态代理是什么
import java.lang.reflect.Proxy;
A．创建一个实现接口InvocationHandler的类，他必须实现invoke方法
B．创建被代理的类以及接口。
C．通过Proxy的静态方法newProxyInstance（ClassLoader loader，Class【】interfaces，InvocationHandler handler）创建一个代理
D．通过代理调用方法。
java动态代理：是在运行是生成的class对象，在生成时必须提供一组或一个interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当做这些interface中的任何一个来用，当然，这个DynamicProxy其实就是一个Proxy，他不会替你做实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。因此，DynamicProxy必须实现InvocationHandler接口。
5）一个动态代理了和一个InvocationHandler实现关联的。每一个动态代理实例的调用都要通过InvocationHandler接口的handler（调用处理器）来调用，动态代理不做任何执行操作，只是在创建动态代理时，把要实现的接口和handler关联，动态代理要帮助被代理执行的任务，要转交给handler来执行。其实就是调用invoke方法。
Java静态代理和iOS代理模式这两个概念的理解上的疑惑
java静态代理模式,举例给你，看下如何理解：
public class Ts{
public static void main(String[] args) throws Exception{
//通过中介公司生产一批衣服
ClothingProduct cp= new ProxCompany( new LiNingCompany());
cp.productClothing();
}
}
/**
*定义生产一批衣服功能的接口
*
*/
interface ClothingProduct{
void productClothing();//有生产一批衣服的功能
}
/**
*
*代理类：中介公司
*
*/
class ProxCompany implements ClothingProduct{
private ClothingProduct cp;//中介公司不会生产衣服，需要找一家真正能生产衣服的公司
ProxCompany(ClothingProduct cp){
super();
this. cp= cp;
}
@Override
public void productClothing(){
System. out.println("收取1块钱的中介费");
cp.productClothing();
}
}
/**
*
*李宁公司是生产服装的目标类
*
*/
class LiNingCompany implements ClothingProduct{
@Override
public void productClothing(){
System. out.println("生产一批衣服。。。。");
}
}
上面程序的做法，使用的模式是静态代理模式
静态代理模式在现实编程中的弊端：
它的特征是代理类和目标对象的类都是在编译期间确定下来的，不利于程序上的扩展，上面示例中，如果客户还想找一个“生产一批鞋子”的工厂，那么还需要新增加一个代理类和一个目标类。如果客户还需要很多其他的服务，就必须一一的添加代理类和目标类。那就需要写很多的代理类和目标类
代理模式到底做了什么？
我眼中的代理模式只有两个关注点：协议和代理者
协议定义了一组方法，由某一个类负责实现。
代理者作为某个类的一个属性，通常是另一个类的实例对象，可以负责完成原来这个类不方便或者无法完成的任务。
首先谈一谈代理者，在脑中重新回想一下代理模式的实现过程。在页面B中定义一个代理对象的时候，好像和定义一个普通的property非常类似（除了 weak和id《delegate》>）。这也正是我对代理的概括：代理本来就是一个属性而已，并没有非常神秘。
当然，代理者并不只是一个类普通的属性，否则我只需要重写一下B的初始化方法即可达到同样的效果：
self.BVC= [[BViewController alloc]initWithDelegate:self];
然后在BViewController.m中定义一个AViewController*AVC并在初始化方法中赋值即可。
注意到代理者在定义的时候，格式往往是这样的：
id<SomeDelegate> delegate;
所以我对代理的优势的理解是：
代理的核心优势在于解耦
与直接声明一个属于某个固定的类的代理者相比，声明为id的代理者具备两个明星的优势。
允许多个不同的类成为本类的代理。试想一下在本文例子中，如果页面B可以跳转回N个页面，如果还是通过声明一个普通对象的方式，那怎么办？
允许代理者的类还不固定。试想一下，UITableView也有delegate，它根本不知道那个类会成为它的代理者。
再看一看协议。协议更加简单了。协议只是定义了一组方法。在代理模式中，完全可以不用在页面B中定义一个协议，然后A再去遵循这个协议。直接调用A的方法即可。
个人认为协议的优点在于以下几点：
可以利用Xcode的检查机制。对于定义为@required的方法，如果实现了协议而没有实现这个方法，编译器将会有警告。这样可以防止因为疏忽，忘记实现某个代码的情况，而由于OC的运行时特性，这样的错误往往在运行阶段才会导致程序崩溃。
有利于代码的封装。如果一个类，实现了某个协议，那么这个协议中的方法不必在.h中被声明，就可以被定义协议的类调用。这样可以减少一个类暴露给外部的方法。
有利于程序的结构化与层次化。一个协议往往是解决问题的某个方法，对于一个其他的不过却类似的问题，我们只用再次实现协议即可，避免了自己再次构思一组方法。协议的继承机制使得这一有点更加强大。
说了怎么多，总结起来只有一句：代理模式并不神秘，只是一个经过了优化的小技巧（让某个类持有另一个类的指针）。代理和协议也只是让程序耦合度更低，结构感更强而已。
什么是java代理模式和java中的代理是什么意思的问题分享结束啦，以上的文章解决了您的问题吗？欢迎您下次再来哦！