(尚硅谷)21 反射的应用-动态代理-AOP代理的实现

<span style="font-size:18px;">复习
//了解体会反射
package com.atguigu.review;
import java.lang.reflect.Constructor;
import org.junit.Test;
/*
 *java.lang.Class反射的源头 
 * 1)人和一个java源文件经过编译后(java.exe)
 * 声明为一个活多个字节码文件(.class)
 * .class文件经过java.exe解释运行,需要使用JVM的类的加载器加载到缓存(运行时类)
 * 那么加载到缓存中的.class文件就对应这一个Class实例
 * 2)任何一个运行时类之加载一次，生成唯一的Class对象
 * 3)如何获取运行时类对应的大的Class 实例*(三种方法)
 */
public class REFLECT {
	@Test
	public void Test1(){
		//第一种方法,直接调用运行时类的.class属性
		Class clazz1 = person.class;
		System.out.println(clazz1);
		clazz1 = com.atguigu.review.person.class;
		System.out.println(clazz1);
	}
	@Test
	public void Test2(){
		//第二种方法,通过运行时类的getClass()
		person p = new person();
		Class clazz2 = p.getClass();
		System.out.println(clazz2);
	}
	@Test
	public void Test3() throws Exception{
		//第三种,调用class的静态方法forName(String className)报异常
		String className  = "com.atguigu.review.person";
		Class clazz3 = Class.forName(className);
		System.out.println(clazz3);
	}
	@Test
	public void Test4() throws Exception{
		//第四种,通过类的加载器调用
		String className  = "com.atguigu.review.person";
		ClassLoader loader = this.getClass().getClassLoader();
		Class clazz = loader.loadClass(className);
		System.out.println(clazz);
	}
	public Object getObject(String str)throws Exception{
		return Class.forName(str).newInstance();
	}
	@Test
	public void Test5()throws Exception{
		String className  = "com.atguigu.review.person"; 
		Object obj = getObject(className);
	}
	/*
	 * 有了Class类后
	 * 1)用来调用运行时类的对象①调用Class的newInstance()②调用制定的构造器
	 * 2)可以获取运行时类的完整的结构
	 * 3)可以调用云翔时类的属性方法构造器..
	 */
	@Test
	public void Test()throws Exception {
		String className  = "com.atguigu.review.person"; 
		Class clazz = Class.forName(className);
		//newInstance()调用的是空参的构造器
		//大家创建一个类时，通常提供方一个空参的构造器
		Object obj = clazz.newInstance();
		person p = (person)obj;
		System.out.println(p);
	}
	@Test
	public void Test12()throws Exception {
		String className  = "com.atguigu.review.person"; 
		Class clazz = Class.forName(className);
		Constructor con = clazz.getDeclaredConstructor(String.class , int.class);
		con.setAccessible(true);
		Object obj = con.newInstance("王琪",90);
		person p = (person)obj;
		System.out.println(p);
	}
	/*
	 * 可以获取对应运行时类的运行中声明的所有类的结构：属性，方法，构造器，内部类
	 * 父类，接口，包，异常，注解..
	 * File[] getFields():可以获取运行时类中及其父类中所有的public属性
	 * File[] getDeclaredFields():可以获取运行时类本身定义的声明为任何权限的属性
	 */
}
复习实例反射调用---
package com.atguigu.review;
public class Animal {
	public String name ;
	private int id ;  
	private static String desc ;
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name ;
	}
	public int getId(){
		return id;
	}
	public static String getDesc() {
		return desc;
	}
	public static void setDesc(String desc) {
		Animal.desc = desc;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Animal() {
		super();
	}
	public Animal(String name, int id) {
		super();
		this.name = name;
		this.id = id;
	}
	public void show(){
		System.out.println("我是一个动物");
	}
	public static String display(){
		return desc;
	}
	public String info(String style){
		return "我是动物:"+style;
	}
	public String toString (){
		return "Animal"+name+"id "+id;
	}
}
package com.atguigu.review;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
public class TestCLazz {
	@Test
	public void Test1() throws Exception{
		//1.获取Class实例
		Class clazz = Animal.class;
		//2.创建对应的运行时类
		//方法一:newInstance();
		Object obj = clazz.newInstance();
		Animal a = (Animal)obj ;
		System.out.println(a);
		//3.调用制定的运行时类的属性
		Field name = clazz.getDeclaredField("name");
		name.setAccessible(true);
		name.set(a, "Tom猫");
		
		Field id = clazz.getDeclaredField("id");
		id.setAccessible(true);
		id.set(a, 10);
		
		System.out.println(a);
		
		Field desc = clazz.getDeclaredField("desc");
		desc.setAccessible(true);
		desc.set(a, "可爱");
		System.out.println(desc.get(a));
		System.out.println(desc.get(Animal.class));
	}
	@Test
	public void Test2() throws Exception{
		Class clazz = Animal.class;
		//方法二：获取对应的运行时的类对象
		Object returnVal = null;
		Constructor cons = null;
		Animal a =null;
		try {
			cons = clazz.getDeclaredConstructor(String.class , int.class);
			cons.setAccessible(true);
			a= (Animal)cons.newInstance("jerry老鼠",12);
			//获取运行时类中制定的方法
			Method method1 = clazz.getDeclaredMethod("show");
			returnVal = method1.invoke(a);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(returnVal);
		
		Method method2 = clazz.getDeclaredMethod("info", String.class);
		method2.setAccessible(true);
		Object obj1 = method2.invoke(a, "老鼠");
		System.out.println(obj1);
		
		Method method3 = clazz.getDeclaredMethod("display");
		method3 .setAccessible(true);
		Object return2 = method3 .invoke(Animal.class);
		System.out.println(return2);
	}
}
package com.atguigu.review;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
public class REFLECT2 {
	@Test
	public void Test1()throws Exception{
		//获取Class实例
		//1.直接调用
		//Class clazz = Animal.class;
		//Class clazz = com.atguigu.review.Animal.class
		//2.调用类对象的实例
		//Animal animal = new Animal();
		//Class clazz = animal.getClass();
		//3调用Class的讲台方法加载器
		//Class clazz = Class.forName(new String("com.atguigu.review.Animal"));
		//4.调用类的加载器
		ClassLoader loader = this.getClass().getClassLoader();
		Class clazz = loader.loadClass(new String("com.atguigu.review.Animal"));
		System.out.println(clazz);
		//2-1创建对应运行时类的对象
		Object obj = clazz.newInstance();
		Animal animal = (Animal)obj;
		System.out.println(animal);
		//3-1调用制定运行时类的属性 
		Field name = clazz.getDeclaredField("name");
		name.setAccessible(true);
		name.set(animal, "王琪");
		System.out.println(name.get(animal));
		
		Field id = clazz.getDeclaredField("id");
		id.setAccessible(true);
		id.setInt(animal, 12);
		System.out.println(animal);
		//调用静态的属性
		Field desc = clazz.getDeclaredField("desc");
		desc.setAccessible(true);
		desc.set(animal, "王琪琪");
		//通过类来调用
		System.out.println(desc.get(Animal.class));
	}
	@Test
	public void Test2()throws Exception{
		ClassLoader loader = this.getClass().getClassLoader();
		Class clazz = loader.loadClass("com.atguigu.review.Animal");
		//调用运行时类的对象的方法
		Object obj = clazz.newInstance();
		Animal animal = (Animal)obj;
		Field name = clazz.getDeclaredField("name");
		name.setAccessible(true);
		name.set(animal, "小老鼠");
		Field age = clazz.getDeclaredField("id");
		age.setAccessible(true);
		age.set(animal, 12);
		System.out.println(animal);
		Method method = clazz.getMethod("info" , String.class);
		method.setAccessible(true);
		System.out.println(method.invoke(animal, "我实际上我没有电话"));
		Field desc = clazz.getDeclaredField("desc");
		desc.setAccessible(true);
		desc.set(Animal.class, "年后回家");
		Method display = clazz.getDeclaredMethod("display");
		display.setAccessible(true);
		System.out.println(display.invoke(Animal.class));
	}
}
Java的代理方法—静态代理—反射代理
 <img src="https://img-blog.csdn.net/20140825203634586?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMjY1MTM4OQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" width="300" height="300" alt="" />
1.静态代理方法
package com.atguigu.teacher;
public class NikeClothFactory implements ClothFactory{
	@Override
	public void produceCloth() {
		System.out.println("Nike工厂生产");
	}
}

package com.atguigu.teacher;
//经态代理
public class TestFactory {
	public static void main(String[] args) {
		ClothFactory w = new NikeClothFactory();
		ProxyClothFactory cf = new ProxyClothFactory(w);
		cf.produceCloth();
	}
}
interface ClothFactory{
	void produceCloth();
}
class ProxyClothFactory implements ClothFactory{
	ClothFactory cf ;
	public ProxyClothFactory (ClothFactory cf){
		this.cf = cf ;
	}
	@Override
	public void produceCloth() {
		System.out.println("代理类获取中介费1000");
		cf.produceCloth();
	}
}
1.	动态代理的方法一
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。 动态代理使用场合:调试 远程方法调用 代理设计模式的原理:       使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上 
package com.atguigu.teacher;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class TestActiveFactory {
	public static void main(String[] args) {
		MyInvocationHannder handler = new MyInvocationHannder();
		RealSubject real = new RealSubject();
		Object obj  = handler.blind(real);//obj即为代理类的对象
		Subject proxy = (Subject) obj;
		proxy.action();//使用代理类的对象调用的被重写的抽象方法
		System.out.println("***********");
		NikeClothFactory nike = new NikeClothFactory();
		Object obj1 = handler.blind(nike);
		ClothFactory proxy1 = (ClothFactory) obj1 ;//Obj1 就是代理类的对象
		proxy1.produceCloth();
	}
}
interface Subject {
	void action();
}
//代理类
class RealSubject implements Subject {
	@Override
	public void action() {
		System.out.println("QI工厂生产");
	}
}
//创建一个实现了InvocationHandler接口的类
class MyInvocationHannder implements InvocationHandler {
	Object obj;//声明的被代理的变量
	public Object blind(Object obj) {
		this.obj = obj;//实例化被代理的变量
		//返回一个与Object 实现了同样的接口的类(即为代理类)
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), this);
	}
	/*凡是通过代理类的对象调用其实际接口的被重写的抽象方法时
	 * 都会转换为对如下的Invoke方法的调用
	 * 此invoke()方法返回值即为被重写的抽象方法的返回值
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object returnVal = method.invoke(obj, args);
		return returnVal;
	}

}
</span>

<span style="font-size:18px;">package com.atguigu.reflect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Human {
	void info();
	void fly();
}
public class TestAop {
	public static void main(String[] args) {
		SuperMan su = new SuperMan();
		Object obj = MyProxy.getProxyInstance(su);
		Human h = (Human)obj;
		h.info();
		h.fly();
	}
}
class SuperMan implements Human {
	@Override
	public void info() {
		System.out.println("我是超人我怕人");
	}
	@Override
	public void fly() {
		System.out.println("我要飞！！");
	}
}
class HumanUtil {
	public void method1() {
		System.out.println("-----通用方法1-----");
	}
	public void method2() {
		System.out.println("-----通用方法2-----");
	}
}
class MyInvocationHandler2 implements InvocationHandler {
	Object obj;

	public void setObject(Object obj) {
		this.obj = obj;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		HumanUtil util =new HumanUtil();
		util.method1();
		Object ret = method.invoke(obj, args);
		util.method2();
		return ret;
	}
}
// 分离
class MyProxy {
	public static Object getProxyInstance(Object obj) {
		MyInvocationHandler2 handler = new MyInvocationHandler2();
		handler.setObject(obj);
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), handler);
	}
}</span>

<span style="font-size:18px;">1．网络通信
package com.atguigu.Net;
import java.net.InetAddress;
import java.net.UnknownHostException;
/*
 * 1.网络编程中的两个主要问题
 * 	>如何尊却定位网络上的一台或多台主机
 *  >找到主机后如何可靠高效的进行数据传输
 * 2.实现网络通信的两个要素：①IP地址 ,端口号 ②传输协议
 * 3.如何创建一个InetAdress类对象
 *  ①调用静态的getByName(String hostName)   
 *      ①域名 ②分配了一串数值：IP地址
 *  ②getLocalHost () 获取本地的地址
 *  4.getAdress的常用方法 : getHostName() ; getHostAdress()
 * 	
 */
public class InetAddressTest {
	public static void main(String[] args) {
		//实例化InetAddress对象,getByName();
		InetAddress inet = null;
		try {
			inet = InetAddress.getByName("www.atguigu.com");
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		//两个方法的使用：getHostName() getHostAdress()
		System.out.println(inet);
		System.out.println(inet.getHostAddress());
		System.out.println(inet.getHostName());
		/*******************************/
		InetAddress inte1  = null;
		try {
			inte1 = InetAddress.getByName("42.121.6.2");
		} catch (UnknownHostException e1) {
			e1.printStackTrace();
		}
		System.out.println(inte1);
		System.out.println(inte1.getHostAddress());
		System.out.println(inte1.getHostName());
		/**********************************/
		InetAddress inet2 = null;
		try {
			inet2 = inet.getLocalHost();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		System.out.println(inet2);
		System.out.println(inet2.getHostAddress());
		System.out.println(inet2.getHostName());
	}
}
/*************************************************/
package com.atguigu.Net;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
public class TestNet {
	public static void main(String[] args) {
		Thread p1 = new Thread(new test1());
		Thread p2 = new Thread(new test2());
		Thread p3 = new Thread(new test2());
		p2.setName("kehu1");
		p3.setName("kehu2");
		p1.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		p2.start();
	}
}
class test1 implements Runnable{
	public void run(){
		Server s = new Server(9012);
		s.read();
		System.out.println("3333");
	}
}
class test2 implements Runnable{
	public void run(){
		Client c =null;
		try {
			c =new Client(InetAddress.getByName("192.168.0.105") ,9012 );
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		c.getConnect();
		c.talk();
	}
}
class Client{
	private InetAddress inet ; 
	private int port ; 
	private Socket socket ; 
	public Client (InetAddress inet , int port){
		this.inet = inet ;
		this.port = port;
		System.out.println("客户端 目的地加载完成："+inet+" "+port);
	}
	public void getConnect(){
		try {
			System.out.println("客户端启动..");
			socket = new Socket(inet, port);
			System.out.println("客户端启动完成!");
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("连接成功"+inet.getHostName());
	}
	public void talk(){
		BufferedReader bin  = new BufferedReader(new InputStreamReader(System.in)); 
		String str = "";
		BufferedWriter bw = null;
		try {
			bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); 
			System.out.println("开始通话..");
			while((str = bin.readLine())!=null){
				System.out.println(Thread.currentThread().getName());
				if(str.equalsIgnoreCase("by")){
					socket.shutdownOutput();
					break;
				}
				bw.write(str);
				bw.newLine();
				bw.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bin!=null){
				try {
					bin.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bw!=null){
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(socket!=null){
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
class Server{
	ServerSocket serverSocket =null ;
	Socket socket = null;
	public Server (int doc){
		try {
			System.out.println("服务器加载..");
			serverSocket =new ServerSocket(9012);
			socket =serverSocket.accept();
		} catch (IOException e) {
			e.printStackTrace();
		}
	    System.out.println("waiting..");
	}
	public void read(){
		BufferedReader bin =null;
		try {
			bin = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		String str = null;
		try {
			while((str = bin.readLine())!=null){
				System.out.println(str+"-->"+socket.getInetAddress().getHostName());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bin!=null){
				try {
					bin.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(socket!=null){
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(serverSocket!=null){
				try {
					serverSocket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
}
/******************************************************************/
package com.atguigu.Net;
import java.net.Socket;
public interface Writer {
	Socket getSocket();
}
package com.atguigu.Net;
import java.net.Socket;
public interface Lisener {
	Socket getSocket();
}
package com.atguigu.Net;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class Clinet2 implements Lisener , Writer{
	private Socket socket = null;
	private InetAddress inet = null;
	private int code ;
	public Clinet2(InetAddress inet , int codde){
		this.inet = inet;
		this.code = codde;
		try {
			socket = new Socket(inet , code);
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("建立客户端...");
	}
	public Socket getSocket() {
		return socket;
	}
	public void setSocket(Socket socket) {
		this.socket = socket;
	}
	public InetAddress getInet() {
		return inet;
	}
	public void setInet(InetAddress inet) {
		this.inet = inet;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
}
package com.atguigu.Net;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server2 implements Lisener , Writer{
	ServerSocket serverSocket2 =null ;
	int codde ; 
	Socket socket ;
	public Server2( int codde){
		this.codde = codde ;
		try {
			serverSocket2 = new ServerSocket( codde );
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("建立服务器..");
		try {
			socket = serverSocket2.accept();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("建立服务器完成..");
	}
	public ServerSocket getServerSocket2() {
		return serverSocket2;
	}
	public void setServerSocket2(ServerSocket serverSocket2) {
		this.serverSocket2 = serverSocket2;
	}
	public int getCodde() {
		return codde;
	}
	public void setCodde(int codde) {
		this.codde = codde;
	}
	@Override
	public Socket getSocket() {
		return socket;
	}
}
package com.atguigu.Net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
public class ClentReadThread implements Runnable{
	private Lisener client =null;
	private InputStream in =null ;
	private BufferedReader bn = null;
	private Socket socket;
	public ClentReadThread (Lisener client){
		this.client = client;
		socket = client.getSocket();
		System.out.println("listener waiting..");
	}
	public void run(){
		try {
			in =socket.getInputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}
	   listener();
	}
	public synchronized void listener(){
		try {
			in =socket.getInputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}
			bn = new BufferedReader(new InputStreamReader(in));
			String str = null;
			System.out.println(Thread.currentThread().getName()+" listen..");
			try {
				while(true){
					str = bn.readLine();
					if(str.equalsIgnoreCase("by")){
						socket.shutdownInput();
						break;
					}
					System.out.println(Thread.currentThread().getName()+":"+str);
				}
			} catch (IOException e) {
		}
	}
}
package com.atguigu.Net;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
public class ClentWriterThread implements Runnable{
	private Writer client =null;
	private OutputStream out =null ;
	private BufferedWriter bn = null;
	private Socket socket;
	public ClentWriterThread (Writer client){
		this.client = client;
		socket = client.getSocket();
		System.out.println("Socket联接");
	}
	public void run(){
		System.out.println("开..");
		try {
			out =socket.getOutputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}
		 writer();
	}
	public synchronized void writer(){
		System.out.println("开..");
		try {
			out =socket.getOutputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}
		BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));
		bn = new BufferedWriter(new OutputStreamWriter(out));
		String str = "hehe!!";
		try {
			while((str = bin.readLine())!=null){
				if(str.equalsIgnoreCase("by")){
					socket.shutdownOutput();
					break;
				}
				try {
					bn.write(str);
					bn.newLine();
					bn.flush();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
package com.atguigu.Net;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.junit.Test;
//2.客户端给服务端发送信息，服务端收到信息打印到控制台，
public class TestNet2 {
	Server2 server ;
	@Test
	public void Servered() {
		 server = new Server2(9090);
		new ClentReadThread(server).listener();
//		Thread serverlisenner = new Thread(new ClentReadThread(server));
//		serverlisenner.setName("serverlisenner");
//		serverlisenner.start();
//		System.out.println("serverlisenner..begin");
	}
	@Test
	public void Clindered(){
		Clinet2 clinder = null ;
		try {
			clinder = new Clinet2(InetAddress.getLocalHost(),9090);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}
		new ClentWriterThread(clinder).writer();
//		Thread ClinderWriter = new Thread(new ClentWriterThread(clinder));
//		ClinderWriter.setName("ClinderWriter");
//		ClinderWriter.start();
//		System.out.println("ClinderWriter..begin");
	}
}
</span>