java设计模式之代理模式（静态代理）

  今天给你们分享的是java设计模式之代理模式中的静态代理模式，动态代理模式将在后面文章中给出。若有不足，敬请指正。

---

1、代理模式是什么

• 代理模式是面向对象编程的 23 种基础设计模式之一。
• 代理模式的定义： 为其余对象（源对象） 提供一种代理以控制对这个对象（源对象） 的访问。

 需求： DAO 层的代码操做。咱们知道分别有

1. 得到数据库链接（相同的）
2. 得到操做对象（相同的）
3. 封装参数（每一个方法都不一样的）
4. 操做（每一个方法都不一样的）
5. 关闭（相同的）

• 经过代理模式，将 DAO 的实现类，相同的代码理解放在代理类里面实现。 咱们 DAO 的实现类只要编写封装参数以及操做就能够了。

---

2、代码示例

2.1 建立一个原始类接口

package com.xkt.dao;

/**
 * @author lzx
 *
 * @param <T>
 */
public interface DAO<T> {
	/**
	 * 增长记录
	 * 
	 * @param entity
	 * @return
	 */
	int insert(T entity);

	/**
	 * 删除记录
	 * 
	 * @param id
	 * @return
	 */
	int deleteById(Integer id);

	/**
	 * 查询记录
	 * 
	 * @param id
	 * @return
	 */
	T findById(Integer id);

	/**
	 * 记录
	 * 
	 * @param entity
	 * @return
	 */
	int update(T entity);
}

2.2 建立一个原始类

package com.xkt.dao;

import com.xkt.pojo.Student;

/**
 * @author lzx
 *
 */
public class StudentDAO implements DAO<Student> {
	@Override
	public int insert(Student entity) {
		// 3.封装参数（每一个方法都不一样的）
		System.out.println("-封装插入数据-");
		// 4.操做（每一个方法都不一样的）
		System.out.println("-操做-插入数据-" + entity.getStudentName());
		return 1;
	}

	@Override
	public int deleteById(Integer id) {
		// 3.封装参数（每一个方法都不一样的）
		System.out.println("-封装删除数据-");
		// 4.操做（每一个方法都不一样的）
		System.out.println("-操做-插入数据-");
		return 1;
	}

	@Override
	public Student findById(Integer id) {
		// 3.封装参数（每一个方法都不一样的）
		System.out.println("-封装查询数据-");
		// 4.操做（每一个方法都不一样的）
		System.out.println("-操做-查询数据-");
		return null;
	}

	@Override
	public int update(Student entity) {
		// 3.封装参数（每一个方法都不一样的）
		System.out.println("-封装更新数据-");
		// 4.操做（每一个方法都不一样的）
		System.out.println("-操做-更新数据-");
		return 1;
	}
}

2.3 建立一个代理类

注意:代理类与原始类都须要实现相同的接口

package com.xkt.proxy;

import com.xkt.dao.DAO;
import com.xkt.pojo.Student;

public class ProxyDAO implements DAO<Student> {
	private DAO<Student> source;

	public ProxyDAO(DAO<Student> source) {
		this.source = source;
	}

	@Override
	public int insert(Student entity) {
		// 1.得到数据库链接（相同的）
		System.out.println("-得到数据库链接-");
		// 2.得到操做对象（相同的）
		System.out.println("-得到操做对象-");
		int count = source.insert(entity);
		// .关闭（相同的）
		System.out.println("-关闭-");
		return count;
	}

	@Override
	public int deleteById(Integer id) {
		// 1.得到数据库链接（相同的）
		System.out.println("-得到数据库链接-");
		// 2.得到操做对象（相同的）
		System.out.println("-得到操做对象-");
		int count = source.deleteById(id);
		// .关闭（相同的）
		System.out.println("-关闭-");
		return count;
	}

	@Override
	public Student findById(Integer id) {
		// 1.得到数据库链接（相同的）
		System.out.println("-得到数据库链接-");
		// 2.得到操做对象（相同的）
		System.out.println("-得到操做对象-");
		Student student = source.findById(id);
		// .关闭（相同的）
		System.out.println("-关闭-");
		return student;
	}

	@Override
	public int update(Student entity) {
		// 1.得到数据库链接（相同的）
		System.out.println("-得到数据库链接-");
		// 2.得到操做对象（相同的）
		System.out.println("-得到操做对象-");
		int count = source.update(entity);
		// .关闭（相同的）
		System.out.println("-关闭-");
		return count;
	}
}

2.4 测试代码

package com.xkt.test;

import org.junit.Test;
import com.xkt.dao.StudentDAO;
import com.xkt.pojo.Student;
import com.xkt.proxy.ProxyDAO;

public class StudentDAOTest {
	@Test
	public void insert() {
		StudentDAO studentDAO = new StudentDAO();
		ProxyDAO proxyDAO = new ProxyDAO(studentDAO);
		Student entity = new Student();
		entity.setStudentName("张三");
		proxyDAO.insert(entity);
	}
}

---

3、说明

3.1 代理的模式的做用

• 就是使用一个代理类来管理被代理类对象（源对象）的统一处理。咱们将这种统一处理的理解称为控制访问。

3.2 代理模式的缺陷

• 代理类必需要继承或者实现一个基类或者接口！！（很笨重）。每一个接口都要实现一个新的代理 类。
• 每一个方法的逻辑处理，仍是要重复编写。

3.3 如何解决代理模式的缺陷

  可使用动态代理模式。

• 一个代理类能够代理多个对象 ，（不是代理模式一一对应）
• 全部的方法的代码均可以统一处理。

  所谓的动态代理模式，就是能够自由的不指定的使用任何接口来实现代理。所谓的动态就不须要指定代理类的固定接口！！！

---

版权说明：欢迎以任何方式进行转载，但请在转载后注明出处！