1 初识代理模式：
定义：为其他对象提供一种代理以控制对这个对象的访问
结构：
参考实现：
2 体会代理模式:
场景问题: 查询某部门下员工基本信息，如果想看详细，则点击查看
不使用模式下的解决方案：
select person.* , dept.* from person, dept where person.deptid = dept.id and dept.id = ？
使用模式的解决方案:
1+N次查询：
select person.name, person.id from person, dept where person.deptid = dept.id and dept.id = ？
将最常用的字段 查询出来，放在代理对象中，
代理对象引用真实对象，将代理对象中需要查看的真实对象的 getXX setXX 通过再次查询数据库得到后放在代理对象中 eg: 查询 sex age location等
这就是1+N次查询，N表示有多少个bean对象，就有可能点击每一个实体对象查看详细，这时就需要重新连接数据库查询N次，不过这是个概率问题，不可能得到N次这么多次， 这是明显是花销多时间，少空间的做法，所有的字段只有在需要的时候才会被加载，第一次加载的都是最少的字段；（主要为了节约内存考虑，hibernate的 lazy load也是用这种思路）
参考代码如下： 如下代理是 虚代理(虚拟真实对象)
package cn.javass.dp.proxy.example3;
/**
* 定义用户数据对象的接口
*/
public interface UserModelApi {
public String getUserId();
public void setUserId(String userId);
public String getName();
public void setName(String name);
public String getDepId();
public void setDepId(String depId);
public String getSex();
public void setSex(String sex);
}
package cn.javass.dp.proxy.example3;
/**
* 描述用户数据的对象
*/
public class UserModel implements UserModelApi{
/**
* 用户编号
*/
private String userId;
/**
* 用户姓名
*/
private String name;
/**
* 部门编号 代理时才加载
*/
private String depId;
/**
* 性别 代理时才加载
*/
private String sex;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDepId() {
return depId;
}
public void setDepId(String depId) {
this.depId = depId;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString(){
return "userId="+userId+",name="+name+",depId="+depId+",sex="+sex+"\n";
}
}
package cn.javass.dp.proxy.example3;
import java.sql.*;
import java.util.*;
/**
* 代理对象,代理用户数据对象
=================主要是看代理对象引用真实对象 和 代理对象中 relaod()写法
*/
public class Proxy implements UserModelApi{
/**
* 持有被代理的具体的目标对象
*/
private UserModel realSubject=null;
/**
* 构造方法，传入被代理的具体的目标对象
* @param realSubject 被代理的具体的目标对象
*/
public Proxy(UserModel realSubject){
this.realSubject = realSubject;
}
/**
* 标示是否已经重新装载过数据了 针对字段 depId 和 sex而言
*/
private boolean loaded = false;
public String getUserId() {
return realSubject.getUserId();
}
public void setUserId(String userId) {
realSubject.setUserId(userId);
}
public String getName() {
return realSubject.getName();
}
public void setName(String name) {
realSubject.setName(name);
}
public void setDepId(String depId) {
realSubject.setDepId(depId);
}
public void setSex(String sex) {
realSubject.setSex(sex);
}
public String getDepId() {
//需要判断是否已经装载过了
if(!this.loaded){
//从数据库中重新装载
reload();
//设置重新装载的标志为true
this.loaded = true;
}
return realSubject.getDepId();
}
public String getSex() {
if(!this.loaded){
reload();
this.loaded = true;
}
return realSubject.getSex();
}
/**
* 重新查询数据库以获取完整的用户数据
*/
private void reload(){
System.out.println("重新查询数据库获取完整的用户数据，userId=="+realSubject.getUserId());
Connection conn = null;
try{
conn = this.getConnection();
String sql = "select * from tbl_user where userId=? ";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, realSubject.getUserId());
ResultSet rs = pstmt.executeQuery();
if(rs.next()){
//只需要重新获取除了userId和name外的数据
realSubject.setDepId(rs.getString("depId"));
realSubject.setSex(rs.getString("sex"));
}
rs.close();
pstmt.close();
}catch(Exception err){
err.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public String toString(){
return "userId="+getUserId()+",name="+getName()
+",depId="+getDepId()+",sex="+getSex()+"\n";
}
private Connection getConnection() throws Exception {
Class.forName("oracle.jdbc.driver.OracleDriver");
return DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:orcl", "test", "test");
}
}
public class UserManager {
/**
* 根据部门编号来获取该部门下的所有人员
* @param depId 部门编号
* @return 该部门下的所有人员
*/
public Collection<UserModelApi> getUserByDepId(String depId)throws Exception{
Collection<UserModelApi> col = new ArrayList<UserModelApi>();
Connection conn = null;
try{
conn = this.getConnection();
//只需要查询userId和name两个值就可以了
String sql = "select u.userId,u.name "
+"from tbl_user u,tbl_dep d "
+"where u.depId=d.depId and d.depId like ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, depId+"%");
ResultSet rs = pstmt.executeQuery();
while(rs.next()){
//这里是创建的代理对象，而不是直接创建UserModel的对象
Proxy proxy = new Proxy(new UserModel());
//只是设置userId和name两个值就可以了
proxy.setUserId(rs.getString("userId"));
proxy.setName(rs.getString("name"));
col.add(proxy);
}
rs.close();
pstmt.close();
}finally{
conn.close();
}
return col;
}
/**
* 获取与数据库的连接
* @return 数据库连接
*/
private Connection getConnection() throws Exception {
Class.forName("oracle.jdbc.driver.OracleDriver");
return DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:orcl", "test", "test");
}
}
public class Client {
public static void main(String[] args) throws Exception{
UserManager userManager = new UserManager();
Collection<UserModelApi> col = userManager.getUserByDepId("0101");
//如果只是显示用户名称，那么不需要重新查询数据库 有效减少查询DB需要的内存 时间 典型的以时间换空间的做法
for(UserModelApi umApi : col){
System.out.println("用户编号：="+umApi.getUserId()+",用户姓名：="+umApi.getName());
}
//如果访问非用户编号和用户姓名外的属性，那就会重新查询数据库， 此时使用代理的包装方法来获取 其余属性
for(UserModelApi umApi : col){
System.out.println("用户编号：="+umApi.getUserId()+",用户姓名：="+umApi.getName()+",所属部门：="+umApi.getDepId());
}
}
}
3 理解代理模式：
认识代理模式: 客户端操作代理对象，代理操作真实对象， 代理对象夹在客户端和真实对象之间，相当于一个中转，我们可以再中转过程中，增加一些自定义功能，eg: 判断权限，只有权限足够下才可以调用真实对象，否则跳转登陆
代理对象和真实对象之间必须是一一对象的关系吗？
这种一一对应关系经常在虚代理下才有；
代理模式顺序图：
Java中的静态代理：（即自己手写接口实现类）
前面自己实现的代理模式，成为Java静态模式，特点就是 有共同接口，代理类和目标类实现这个接口，
缺点就是如果接口发生改变，那么代理类和目标都要变化不灵活。
Java中的动态代理：（交给Javase.reflect.invocationhandler来动态实现 取代手写方式）
依靠反射机制+动态生成类 = 生成动态代理对象 同样也是实现接口上的很多方法，
但是特点是：动态代理类只有一个方法invoke,即使接口方法变更时，动态代理也不需要变更(用一个高层抽象方法将变化给屏蔽掉)
Javaee动态代理使用案例： spring aop 面向切面编程
Java动态代理代码：
接口：
package cn.javass.dp.proxy.example5;
/**
* 订单对象的接口定义
*/
public interface OrderApi {
/**
* 获取订单订购的产品名称
* @return 订单订购的产品名称
*/
public String getProductName();
/**
* 设置订单订购的产品名称
* @param productName 订单订购的产品名称
* @param user 操作人员
*/
public void setProductName(String productName,String user);
/**
* 获取订单订购的数量
* @return 订单订购的数量
*/
public int getOrderNum();
/**
* 设置订单订购的数量
* @param orderNum 订单订购的数量
* @param user 操作人员
*/
public void setOrderNum(int orderNum,String user);
/**
* 获取创建订单的人员
* @return 创建订单的人员
*/
public String getOrderUser();
/**
* 设置创建订单的人员
* @param orderUser 创建订单的人员
* @param user 操作人员
*/
public void setOrderUser(String orderUser,String user);
}
目标类:
package cn.javass.dp.proxy.example5;
/**
* 订单对象
*/
public class Order implements OrderApi{
/**
* 订单订购的产品名称
*/
private String productName;
/**
* 订单订购的数量
*/
private int orderNum;
/**
* 创建订单的人员
*/
private String orderUser;
/**
* 构造方法，传入构建需要的数据
* @param productName 订单订购的产品名称
* @param orderNum 订单订购的数量
* @param orderUser 创建订单的人员
*/
public Order(String productName,int orderNum,String orderUser){
this.productName = productName;
this.orderNum = orderNum;
this.orderUser = orderUser;
}
public String getProductName() {
return productName;
}
public void setProductName(String productName,String user) {
this.productName = productName;
}
public int getOrderNum() {
return orderNum;
}
public void setOrderNum(int orderNum,String user) {
System.out.println("调用到真正方法...");
this.orderNum = orderNum;
}
public String getOrderUser() {
return orderUser;
}
public void setOrderUser(String orderUser,String user) {
this.orderUser = orderUser;
}
public String toString(){
return "productName="+this.getProductName()+",orderNum="+this.getOrderNum()+",orderUser="+this.getOrderUser();
}
}
动态代理类： 获取动态代理类对象的方法中 使用形参来接受真正目标对象，以实现目标对象和代理对象的绑定:
package cn.javass.dp.proxy.example5;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 使用Java中的动态代理
*/
public class DynamicProxy implements InvocationHandler{
/**
* 被代理的对象
*/
private OrderApi order = null;
/**
* 获取绑定好 代理和具体目标对象 后的目标对象的接口 （动态获取获取目标对象的代理对象）
* @param order 具体的订单对象，相当于具体目标对象
*/
public OrderApi getProxyInterface(Order order){
this.order = order;
//把真正的订单对象和动态代理关联起来， 即将创建目标对象的动态代理对象 交给 javase.reflect.invocationhandler来做， 取代你手动new出一个类 手写目标的对象的代理类(这叫Java静态代理)
OrderApi orderApi = (OrderApi) Proxy.newProxyInstance(
order.getClass().getClassLoader(),// 目标对象
order.getClass().getInterfaces(), // 目标对象所有的接口
this);
return orderApi;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("调用目标对象的所有方法前，动态代理下，都会先走我...");
//下面是针对目标对象不同方法添加逻辑判断
//如果是调用setter方法就需要检查权限
if(method.getName().startsWith("set")){
//如果不是创建人，那就不能修改
if(order.getOrderUser()!=null && order.getOrderUser().equals(args[1])){
//可以操作
return method.invoke(order, args);// 用着一句话 代替所有访问真实对象的方法
}else{
System.out.println("对不起，"+args[1]+"，您无权修改本订单中的数据");
}
}else{
//不是调用的setter方法就继续运行
return method.invoke(order, args);
}
return null;
}
}
客户端：
package cn.javass.dp.proxy.example5;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
//张三先登录系统创建了一个订单
Order order = new Order("设计模式",100,"张三");
//创建一个动态代理
DynamicProxy dynamicProxy = new DynamicProxy();
//然后把订单和动态代理关联起来
OrderApi orderApi = dynamicProxy.getProxyInterface(order);
orderApi.getOrderNum();
//以下就需要使用被代理过的接口来操作了
//李四想要来修改，那就会报错
orderApi.setOrderNum(123, "李四");
//输出order
System.out.println("李四修改后订单记录没有变化："+orderApi);
//张三修改就不会有问题
orderApi.setOrderNum(123, "张三");
//再次输出order
System.out.println("张三修改后，订单记录："+orderApi);
}
}
4 思考代理模式：
本质： 控制对象的访问，能增强目标对象的功能，甚至替换目标对象的功能
何时使用：
a) 需要为一个对象在不同地址空间提供局部代表时，可以使用远程代理
b) 需要按照需要创建开销很大的对象时，可以使用虚代理(eg:加载小图标 大图片 查看用户基本资料 详细资料)
c) 需要控制对原始对象访问时，可以使用保护代理
d) 需要在访问对象的时候，执行一些附加操作时，可以使用智能指引代理
5代理模式脑图：
扫一扫
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
