SSH框架-》spring原理02

今天内容就用到一个包

笔记

* 解耦合的第一点：解除的是逻辑耦合
	* MVC第一次解除的是逻辑耦合
	* 昨天的解耦合是深度解耦，使用的IOC进行的深度解耦。
* 项目是要有日志的，用来保持程序的健壮性，日志就是程序的运行记录。


客户要求加需求，加了违反开闭原则，怎么办？加不加？
	（模式：DAO  Factory  模板  MVC  单例  proxy  模式..）
	代理(是一种模式)：proxy（饮料原价，超市卖的贵，是增值，冰的贵1块是包装）不改变原有的类情况下，增强原有类方法的功能。方法执行之前和方法执行之后加些东西
			* 本质：原产品不动，不做任何改变。
			* 要增值
			* 要包装
		*代理分为两类：
        	1.静态代理
        		* 门面模式
        		* 装饰模式
        		* 需要为每一个被代理的方法都写一个代理方法，修改的时候，特别之复杂，不灵活。
        		* 代理真正代理的是被代理对象的方法
        	2.动态代理(没有尊严)：是通用的
        		* jdk动态代理
        			* jdk动态代理劣势：JDK动态代理要想代理对象的话，被代理对象必须有接口，否则，不能代理...
        		* cglib动态代理
        			* 在被代理类没有接口的情况下，也可以代理。原理：给当前类动态生成一个子类。
			* 代理类和被代理类都需要实现同样的接口，代理类和被代理类在行为上是一致的。
			* 代理类当中要包含一个被代理类的对象。
			* 你可以提供两种方式把被代理对象赋给代理对象
			* 调用被代理类实现真正的逻辑，在自己的里面实现额外逻辑 	
		* 动态代理必须jdk1.5以上
		* 代理必然基于反射，没有反射没反射就没办法通用
		* 代理类最终执行的任何方法都会执行到invoke中来.
		* 如果一个新的类和被代理类使用同样的类加载器，实现了同样的接口，name这个新类和代理类基本一致。
		* 代理到最终要求的是简单、通用、灵活(理解各个代理的优缺点！提问)
		

----下面分层次剖析--------------------

package com.anbo.dao;

public class DeptDAO1 {
	public void save(){
		System.out.println("保存了dept数据...");
	}
}

package com.anbo.test;

import com.anbo.dao.DeptDAO1;

public class Test1 {
	public static void main(String[] args) {
		DeptDAO1 dao = new DeptDAO1();
		dao.save();
	}
}

---

package com.anbo.dao;

public interface IDAO2 {
	public void save();
	
	public void merge();
}

package com.anbo.dao;

public class EmpDAO2 implements IDAO2{
	public void save(){
		System.out.println("保存了Emp对象");
	}
	public void merge(){
		System.out.println("merget...");
	}
}

package com.anbo.dao;

public class DeptDAO2 implements IDAO2{
	
	public void save(){
		System.out.println("保存了Dept对象");
	}
	
	public void merge(){
		System.out.println("merge dept....");
	}
	
}

package com.anbo.dao;

import java.util.Date;

/*
 * 1.代理类和被代理类都需要实现同样的接口...
 * 		代理类和被代理类在行为上是一致的
 * 2.代理类要包含一个被代理类的对象
 * 3.你可以提供两种方式把被代理对象赋给代理对象
 * 4.调用被代理类实现真正的逻辑，在自己的里面实现额外逻辑
 * 
 */
public class DAOProxy2 implements IDAO2{
	
	private IDAO2 dao;

	
	
	public DAOProxy2(IDAO2 dao) {
		this.dao = dao;
	}

	public IDAO2 getDao() {
		return dao;
	}

	public void setDao(IDAO2 dao) {
		this.dao = dao;
	}

	@Override
	public void save() {
		System.out.println("日志：开始保存了" + new Date());
		this.dao.save();
		System.out.println("日志：我结束保存了" + new Date());
	}

	@Override
	public void merge() {

		System.out.println("日志：开始保存了" + new Date());
		this.dao.merge();
		System.out.println("日志：我结束保存了" + new Date());
		
	}
}

package com.anbo.test;

import com.anbo.dao.DAOProxy2;
import com.anbo.dao.DeptDAO2;
import com.anbo.dao.IDAO2;

public class Test2 {
	public static void main(String[] args) {
		
		IDAO2 dao = new DeptDAO2();//被代理类对象
		IDAO2 daoproxy = new DAOProxy2(dao);//代理对象
		daoproxy.save();
		dao.save();
		
	}
}

---

package com.anbo.jdkproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 1.JDK1.5(5.0)以上版本
 * 2.代理必然基于反射，没有反射就不能用
 * 
 * IDAO dao = new StudentDAO();//被代理
 * DAOProxy daoproxy = new DAOProxy();
 * Object proxy = daoproxy.bind(dao);
 */
public class DAOProxy3 implements InvocationHandler {

	//被代理对象
	private Object delegate;
	//默认的空的构造器，没用
	public DAOProxy3(){
		
	}
	//bind绑定
	//给我一个被代理对象，我动态的生成一个代理对象返还给你
	public Object bind(Object delegate){
		this.delegate = delegate;
		//如果一个新的类和被代理类使用同样的类加载器，实现了同样的接口，那么这个新类和被代理类基本一致.
		return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
	}
	
	/*
	 * 代理类最终执行的任何方法，都会执行到invoke中来..
	 */
	public Object invoke(Object proxy,Method method , Object[] args) 
			throws Exception{
		
		System.out.println("我在方法前执行了");
		Object result = method.invoke(delegate, args);
		System.out.println("我在方法执行后执行了");
		return result;
		
	}
	
}

package com.anbo.jdktarget;

public interface IDAO3 {
	public void save();
	
	public void merge();
}

package com.anbo.jdktarget;

public class StudentDAO3 implements IDAO3{
	
	public void save(){
		System.out.println("hello world");
	}
	
	public void merge(){
		System.out.println("merge invoke..");
	}
}

package com.anbo.test;

import com.anbo.jdkproxy.DAOProxy3;
import com.anbo.jdktarget.IDAO3;
import com.anbo.jdktarget.StudentDAO3;

public class Test3 {
	public static void main(String[] args) {
		//创建被代理对象
		IDAO3 dao = new StudentDAO3();
		//创建代理对象生成器，DAOProxy用来生成代理对象的
		DAOProxy3 proxy = new DAOProxy3();
		//代理对象
		IDAO3 daoproxy =(IDAO3) proxy.bind(dao);
		//调用新对象的保存方法..
		daoproxy.merge();
	}
}

---

package com.anbo.cgproxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGProxy4 implements MethodInterceptor{
	//被代理对象
		private Object target;
		//为被代理类生成一个代理类
		public Object bind(Object target){
			this.target=target;
			Class cls=target.getClass();
			Enhancer en=new Enhancer();
			en.setSuperclass(cls);
			en.setCallback(this);
			return en.create();
		}
		/*
		 * 代理对象所有的方法 最终都会执行到这儿来。。
		 * @see net.sf.cglib.proxy.MethodInterceptor#intercept(java.lang.Object, java.lang.reflect.Method, java.lang.Object[], net.sf.cglib.proxy.MethodProxy)
		 */
		public Object intercept(Object object, 
								Method method, 
								Object[] args,
								MethodProxy methodproxy
								) throws Throwable {
			System.out.println(method.getName()+"执行开始了......");
			Object result=methodproxy.invoke(target, args);
			System.out.println(method.getName()+"我执行结束了******");
			return result;
		}
}

package com.anbo.cgproxy;

public class StudentDAO4{
	public void save(){
		System.out.println("hello world");
	}
	public void find(){
		System.out.println("find ALL");
	}
}

package com.anbo.test;

import com.anbo.cgproxy.CGProxy4;
import com.anbo.cgproxy.StudentDAO4;

public class Test4 {
	public static void main(String[] args) {
		//代理对象生成器
		CGProxy4 proxy =  new CGProxy4();
		//创建个dao 被代理对象
		StudentDAO4 dao = new StudentDAO4();
		//通过被代理对象生成代理对象
		StudentDAO4 daoproxy = (StudentDAO4) proxy.bind(dao);
		//回去代理生成器中去调用intercept
		daoproxy.save();
		daoproxy.find();
	}
}