扩展已知类的功能

扩展已知类的功能

1.采用子类

缺点：

a、与具体类相关联:

如果继承了该类，那么使用范围就会被固定

继承了Connection，只能在mysql数据库中使用，在其他数据库就使用不了了

b、有些不能继承

c、信息不全

2.采用包装类（装饰者设计模式）

装饰者设计模式的步骤：
1. 在装饰类的内部维护一个被装饰类的引用。
2. 让装饰类有一个共同的父类或者是父接口。

采用包装类扩展已知类的功能
口诀：
a. 写一个类，实现和被包装类相同的接口 (使他们具有相同的行为)
b. 创建一个实例变量，引用被包装类对象 (最好做到与具体类无关)
c. 编写一个构造函数，传入被包装类对象 (注入： DI)
d. 对于需要改写的方法，写自己的代码
e. 对于不需要改写的方法，引用被包装类的对象的对应方法即可

3.静态代理

Person:

package com.heima.proxy;

public class Person {

	public void eat() {
		System.out.println("吃饭");
	}
	
	
	public void sleep(){
		System.out.println("睡觉");
	}
}

ProxyPerson(代理类)：

package com.heima.proxy;

public class ProxyPerson {

	private Person p ;
	
	public ProxyPerson(Person p) {
		this.p = p ;
	}
	
	public void eat() {
		p.eat() ;
	}
	
	
	public void sleep(){
		p.sleep() ;
		System.out.println("睡觉时间： " + System.nanoTime());
	}
	
}

Test:

package com.heima.proxy;

public class Test {

	public static void main(String[] args) {
		ProxyPerson p = new ProxyPerson(new  Person()) ;
		
		p.eat() ;
		p.sleep() ;
	}
}

4.动态代理

Human:(Interface):

package com.heima.proxy1;

public interface Human {

	public void eat() ;
	
	public void sing(float money) ;
	
	public void dance(float money) ;
}

SpringBrother:(来学习的人，实现humen接口)

package com.heima.proxy1;

public class SpringBrother implements Human {

	@Override
	public void eat() {
		System.out.println("吃饭中......");
	}

	@Override
	public void sing(float money) {
		System.out.println("拿到钱： " + money + "开唱");
	}

	@Override
	public void dance(float money) {
		System.out.println("拿到钱： " + money + "跳舞");
	}

}

ProxyHuman:（代理的人，也要实现human接口）

package com.heima.proxy1;

//模拟动态代理的原理
public class ProxyHuman implements Human {
	
	private Human man ;
	
	public ProxyHuman(Human man) {
		this.man = man ;
	}

	@Override
	public void eat() {
		man.eat() ;
	}

	@Override
	public void sing(float money) {
		if(money > 1000)
			man.sing(money/2) ;
	}

	@Override
	public void dance(float money) {
		if(money > 2000)
			man.sing(money/2) ;
	}

}

Test:

package com.heima.proxy1;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		Human man = new SpringBrother() ;
//		
//		man.eat() ;
//		man.sing(100) ;
//		man.dance(200) ;
		
		Human man = new ProxyHuman(new SpringBrother()) ;
		
		man.eat() ;
		man.sing(2000) ;
		man.dance(4000) ;
		
	}

}

基于接口的动态代理

Human:

package com.heima.proxy2;

public interface Human {

	public void eat() ;
	
	public void sing(float money) ;
	
	public void dance(float money) ;
}

SpringBrother:

package com.heima.proxy2;

public class SpringBrother implements Human {

	@Override
	public void eat() {
		System.out.println("吃饭中......");
	}

	@Override
	public void sing(float money) {
		System.out.println("拿到钱： " + money + "开唱");
	}

	@Override
	public void dance(float money) {
		System.out.println("拿到钱： " + money + "跳舞");
	}

}

Test:

package com.heima.proxy2;

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

//基于接口的动态代理
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		Human man = new SpringBrother() ;
//		
//		man.eat() ;
//		man.sing(100) ;
//		man.dance(200) ;
		
		final SpringBrother sb = new SpringBrother() ;
		
		Human man = (Human)Proxy.newProxyInstance(sb.getClass().getClassLoader(),
				sb.getClass().getInterfaces(), 
				new InvocationHandler() {
					
				/**
				 * invoke(Object proxy, Method method, Object[] args)
				 * proxy: 代理人
				 * method: 代理的方法
				 * args: 方法的参数
				 */
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						if(method.getName().equals("sing")){
							//说明要唱歌
							float money = (Float)args[0] ;
							if(money > 1000){
								Object retVal = method.invoke(sb, money/2) ;
								return retVal;
							}else
								return null ;
						}
						if(method.getName().equals("dance")){
							//说明要唱歌
							float money = (Float)args[0] ;
							if(money > 2000){
								Object retVal = method.invoke(sb, money/2) ;
								return retVal ;
							}else
								return null ;
						}
						Object ret =method.invoke(sb, args) ;
						return ret ;
						
					}
				}) ;
		
		man.eat() ;
		man.sing(1500) ;
		man.dance(2500) ;
	}

}

基于子类的动态代理：

采用第三方jar包实现动态代理：

cglib-nodep-2.1_3.jar

SpringBrother:

package com.heima.proxy3;

public class SpringBrother {

	public void eat() {
		System.out.println("吃饭中......");
	}

	public void sing(float money) {
		System.out.println("拿到钱： " + money + "开唱");
	}

	public void dance(float money) {
		System.out.println("拿到钱： " + money + "跳舞");
	}

}

Test:

package com.heima.proxy3;

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 Test {

	public static void main(String[] args) {
		/**
		 * Enhancer.create(type, callback): //创建一个代理对象
		 * type:是被代理对象的类型
		 * callback: 相当于Proxy类中的 invocationHandler 代理类要做的事
		 */
		final SpringBrother sb = new SpringBrother() ;
		SpringBrother h =  (SpringBrother)Enhancer.create(SpringBrother.class, new MethodInterceptor(){
		//创建的代理类的类型也是SpringBrother类型，因为在创建代理类的时候是以子类的形式创建的	
			//即创建的代理对象是被代理的子类
			@Override
			public Object intercept(Object arg0, Method method, Object[] args,
					MethodProxy arg3) throws Throwable {
				if(method.getName().equals("sing")){
					//说明要唱歌
					float money = (Float)args[0] ;
					if(money > 1000){
						Object retVal = method.invoke(sb, money/2) ;
						return retVal;
					}else
						return null ;
				}
				if(method.getName().equals("dance")){
					//说明要唱歌
					float money = (Float)args[0] ;
					if(money > 2000){
						Object retVal = method.invoke(sb, money/2) ;
						return retVal ;
					}else
						return null ;
				}
				Object ret =method.invoke(sb, args) ;
				return ret ;
			}
		}) ;
		
		
		h.eat() ;
		h.sing(1500) ;
		h.dance(2500) ;
	}
}