javaSE---设计模式

2021-01-18 19:34:08 阅读：151 来源： 互联网

标签：package class 代理 wangxing --- javaSE 设计模式 com public

认识设计模式

https://www.runoob.com/design-pattern/design-pattern-tutorial.html

14.1.什么是设计模式？
设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结
14.2.设计模式的作用是什么？
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
14.3.什么是单例模式/单态模式？
单例模式—保证一个类仅有一个实例。
当类被频繁地创建与销毁的时候，我们使用单例模式，这样可以减少了内存的开销，避免对资源的多重占用。
14.4.单例模式的两种表示方式以及区别
1.懒汉式：

package com.wangxing.danli;
/**
 * 单例模式--懒汉式
 * @author Administrator
 *
 */
public class SingleObject1 {
	/*
	 * 1.构造方法私有
	 * 2.提供一个静态成员变量【私有】，用于保存当前类对象
	 * 3.提供一个静态方法【公共】，返回当前创建好的当前类对象
	 */
	//私有构造方法
	private SingleObject1(){
		
	}
	//静态成员变量
	private static SingleObject1 sobj1=null;
	//静态方法--公有
	//为了保证多线程情况下使用是为了保证当前类对象只有一个我们就需要添加synchronized
	public static synchronized SingleObject1 getSingleObject1(){
		if(sobj1==null){
			sobj1=new SingleObject1();
		}
		return sobj1;
	}
}

测试：

package com.wangxing.danli;

public class Testmain {

	public static void main(String[] args) {
		
		 // 测试懒汉式
		SingleObject1 obj1=SingleObject1.getSingleObject1();
		SingleObject1 obj2=SingleObject1.getSingleObject1();
		if(obj1==obj2){
			System.out.println("相等，同一个对象");
		}
		if(obj1.equals(obj2)){
			System.out.println("相等，同一个对象");
		}
		System.out.println("obj1="+obj1.hashCode());
		System.out.println("obj2="+obj2.hashCode());
	}

}

2.饿汉式：

package com.wangxing.danli;
/**
 * 单例模式--饿汉式
 * @author Administrator
 *
 */
public class SingleObject2 {
	/*
	 * 1.构造方法私有
	 * 2.提供一个静态成员变量【私有】，创建当前类对象
	 * 3.提供一个静态方法【公共】，返回当前创建好的当前类对象
	 * 4.为了保证多线程情况下使用是为了保证当前类对象只有一个我们就需要添加synchronized
	 */
	//私有构造方法
	private SingleObject2(){
		
	}
	//静态成员变量
	private static SingleObject2 sobj1=new SingleObject2();
	//静态方法--公有
	//为了保证多线程情况下使用是为了保证当前类对象只有一个我们就需要添加synchronized
	public static synchronized SingleObject2 getSingleObject1(){
		return sobj1;
	}
}

测试：

package com.wangxing.danli;

public class Testmain {

	public static void main(String[] args) {
		//测试饿汉式
		SingleObject2 obj1=SingleObject2.getSingleObject1();
		SingleObject2 obj2=SingleObject2.getSingleObject1();
		if(obj1==obj2){
			System.out.println("相等，同一个对象");
		}
		if(obj1.equals(obj2)){
			System.out.println("相等，同一个对象");
		}
		System.out.println("obj1="+obj1.hashCode());
		System.out.println("obj2="+obj2.hashCode());
	}

}

区别：

	懒汉式	饿汉式
资源利用率	好	差
运行速度	差	好

14.5.什么是工厂模式？
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
1.需求量大
2.牵一发，动全身
有3种角色

工厂角色----【普通类】
抽象产品角色—【抽象类/接口】
具体产品角色----【抽象类/接口子类】

例如:有农场生产各种水果，有西瓜，有苹果，有香蕉…
农场—工厂角色----【类】
水果—抽象产品角色—【抽象类/接口】
西瓜，苹果，香蕉—具体产品角色----【抽象类/接口子类】
抽象工厂模式—提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
14.6.如何编写简单工厂【静态】模式？
接口：

package com.wangxing.factry;
/**
 * 游戏角色接口
 * @author Administrator
 *
 */
public interface JueSe {
	//所有角色具有的公共功能
	void gongji();	
}

工厂类：

package com.wangxing.factry;
/**
 * 工厂类【生产角色】
 * @author Administrator
 *
 */
public class FacTryClass {
	static JueSe createJueSe(String name){
		JueSe js=null;
		if(name.equals("战士")){
			js=new ZhanShi();//接口回调
		}
		if(name.equals("法师")){
			js=new ZhanShi();//接口回调
		}
		if(name.equals("弓箭手")){
			js=new ZhanShi();//接口回调
		}
		return js;
	}
}

具体角色：

package com.wangxing.factry;
/**
 * 法师类【具体产品】
 * @author Administrator
 *
 */
public class FaShi implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是法师，我使用魔法棒攻击怪物！！");
	}
	
	
}

package com.wangxing.factry;
/**
 * 弓箭手类【具体产品】
 * @author Administrator
 *
 */
public class GongJianShou implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是弓箭手，我使用弓箭攻击怪物！！");
	}
	
	
}

package com.wangxing.factry;
/**
 * 战士类【具体产品】
 * @author Administrator
 *
 */
public class ZhanShi implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是战士，我使用刀攻击怪物！！");
	}
	
	
}

测试类：

package com.wangxing.factry;

import java.util.Scanner;

public class TestMain {
/**
 * 测试：
 * @param args
 */
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请选择角色：");
		String name=input.next();
		JueSe js=FacTryClass.createJueSe(name);
		js.gongji();
	}

}

改进：
接口：

package com.wangxing.factry;
/**
 * 游戏角色接口
 * @author Administrator
 *
 */
public interface JueSe {
	//所有角色具有的公共功能
	void gongji();	
}

工厂类：

package com.wangxing.factry;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.HashMap;

/**
 * 工厂类【生产角色】
 * @author Administrator
 *
 */
public class FacTryClass {
	static JueSe createJueSe(String name){
		JueSe js=null;
		try{
		//读取角色列表
		HashMap<String, String> juese=readjueselistmap();
		
		String classname=juese.get(name);
		//通过反射得到对象
		Class classobj=Class.forName(classname);
		js=(JueSe) classobj.newInstance();
		}catch (Exception e) {
			// TODO: handle exception
		}
		return js;
	}
	/**
	 * 读取角色列表
	 * @return
	 * @throws  
	 */
	private static HashMap<String, String> readjueselistmap(){
		HashMap<String, String> jueselist=null;
		try {
		jueselist=new HashMap<String ,String>();
		//创建目标对象
		File file=new File("JueSelist.txt");
		//创建输入流
		FileReader in=new FileReader(file);
		BufferedReader read=new BufferedReader(in);
		String info=null;
		while((info=read.readLine())!=null){
			//拆分键值对保存到hashmap中
			String infoarr[]=info.split("=");
			jueselist.put(infoarr[0],infoarr[1] );
		}
		//关流
		read.close();
		in.close();
		} catch (Exception e) {
		}
		return jueselist;
	}
}

角色列表：

战士=com.wangxing.factry.ZhanShi
法师=com.wangxing.factry.FaShi
弓箭手=com.wangxing.factry.GongJianShou

角色具体类：

package com.wangxing.factry;
/**
 * 法师类【具体产品】
 * @author Administrator
 *
 */
public class FaShi implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是法师，我使用魔法棒攻击怪物！！");
	}
	
	
}

package com.wangxing.factry;
/**
 * 弓箭手类【具体产品】
 * @author Administrator
 *
 */
public class GongJianShou implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是弓箭手，我使用弓箭攻击怪物！！");
	}
	
	
}

package com.wangxing.factry;
/**
 * 战士类【具体产品】
 * @author Administrator
 *
 */
public class ZhanShi implements JueSe{

	@Override
	public void gongji() {
		System.out.println("我是战士，我使用刀攻击怪物！！");
	}
	
	
}

测试类：

package com.wangxing.factry;

import java.util.Scanner;

public class TestMain {
/**
 * 测试：
 * @param args
 */
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请选择角色：");
		String name=input.next();
		JueSe js=FacTryClass.createJueSe(name);
		js.gongji();
	}

}

14.7.什么是代理模式？
为其他对象提供一种代理以控制对这个对象的访问。
买火车票不一定在火车站买，也可以去代售点。
静态代理【兄弟模式的静态代理】：
接口：

package com.wangxing.proxy;

public class DaiShouDian implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离代售点近，到代售点买票");
	}

}

火车站类：

package com.wangxing.proxy;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离火车站近，到火车站买票");
	}

}

代售点类;

package com.wangxing.proxy;

public class DaiShouDian implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离代售点近，到代售点买票");
	}

}

测试类：

package com.wangxing.proxy;

public class TestMain {

	public static void main(String[] args) {
		//选择不同的地方买票
		//火车站
		HuoCheZhan hcz=new HuoCheZhan();
		hcz.maipiao();
		//代售点
		DaiShouDian dsd=new DaiShouDian();
		dsd.maipiao();
	}

}

静态代理【父子模式的静态代理】：
接口：

package com.wangxing.proxy;

public class DaiShouDian implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离代售点近，到代售点买票");
	}

}

火车站类：

package com.wangxing.proxy;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离火车站近，到火车站买票");
	}

}

代售点类;

package com.wangxing.proxy;

public class DaiShouDian extends HuoCheZhan{
	//卖票
	public void maipiao() {
	     System.out.println("家离火车站远，到代售点买票");
	}
}

测试类：

package com.wangxing.proxy;

public class TestMain {

	public static void main(String[] args) {
		//选择不同的地方买票
		//火车站
		HuoCheZhan hcz=new HuoCheZhan();
		hcz.maipiao();
		//代售点
		DaiShouDian dsd=new DaiShouDian();
		dsd.maipiao();
	}

}

静态代理的缺点需要手动创建子类，当需要被代理元素较多的时候，我们的工作量变大了。
由于静态代理的上述缺点，所以我们需要一个专门生产代理对象的类
动态代理–专门由一个类来生产需要被代理的类的代理对象。
有2种方式
JDK动态代理----通过java.lang.reflect Class Proxy类来创建代理类对象。
【只能为实现过某个接口的java类提供代理类对象】

CGlib代理-------CGlib是一个第三发的开发包，用的时候需要自己事先下载导入到项目中
【所有的java类提供代理类对象】

代理模式

14.9.JDK动态代理与CGlib代理的区别
JDK动态代理：
动态代理相比于静态代理，动态代理的代理类是在动态生成的，也就是jvm通过反射获取代码生成代理类，所以用户并不能决定代理角色和真实角色之间的联系，而是由程序运行时候决定的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。
动态代理实现的三步走：

实现InvocationHandler接口，创建自己的调用处理器。
给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类。
执行真实角色具体任务。

要想创建处理器必须实现InvocationHandler接口，之后通过类装载器创建代理类。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy:指代我们所代理的那个真实对象
method:指代的是我们所要调用真实对象的某个方法的Method对象
args:指代的是调用真实对象某个方法时接受的参数

我们依旧要创建抽象角色和真实角色类
接口：

package com.wangxing.test1;
public interface MaoPiaoInterface {
	void  maipiao();
}

火车站：

package com.wangxing.test1;
public class HuoCheZhan implements MaoPiaoInterface{
	@Override
	public void maipiao() {
		System.out.println("火车站买票");
	}

代理角色：和静态代理相比，静态代理运用对象调用完成代理，而动态代理通过实现InvocationHandler接口，创建了一个调用处理器，其实是通过Java的反射机制完成.

package com.wangxing.proxy2;

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

/**
 * 1.需要让生成代理类对象实现InvocationHandler接口
 * 2.重写InvocationHandler接口的invoke方法
 * 3.创建生成代理对象的方法
 * @author Administrator
 *
 */
public class CreateDaiShouDianObject implements InvocationHandler{

	//定义目标对象[具体需要代理对象的Java类]
	private Object targetObject;
	
	public CreateDaiShouDianObject(Object targetObject){
		this.targetObject=targetObject;
	}
	//通过Java提供的Proxy类创建出代理对象
		public Object getProxyObject(){
			return Proxy.newProxyInstance(this.getClass().getClassLoader(), targetObject.getClass().getInterfaces(),this);
		}
	//用来执行具体的代理动作
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		return method.invoke(targetObject, args);
	}

}

package com.wangxing.proxy2;
/**
 * 售票业务接口
 * @author Administrator
 *
 */

public interface SellePiaoService {
	void maipiao();
}

package com.wangxing.proxy2;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan implements SellePiaoService {

	@Override
	public void maipiao() {
		System.out.println("家离火车站近，到火车站买票");
	}

}

测试类：

package com.wangxing.proxy2;

public class TestMain {

	public static void main(String[] args) {
		//选择不同的地方买票
		//火车站
		HuoCheZhan hcz=new HuoCheZhan();
		hcz.maipiao();
		//代售点
		//创建火车站的代理对象
		CreateDaiShouDianObject  cpo=new CreateDaiShouDianObject(hcz);
		//得到代理对象
		SellePiaoService  proxy=(SellePiaoService)cpo.getProxyObject();
		proxy.maipiao();
	}

}

看上去实现很简单，我们只需要实现接口，调用其中的方法就可以实现动态代理。
通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法。
注意：JDK动态代理只能处理有接口实现关系的java类

Cglib代理
cglib是一个强大的高性能的代码生成包，广泛的被许多AOP的框架使用，它的开源地址在https://github.com/cglib/cglib
通过它实现动态代理，主要用到import net.sf.cglib.proxy包下的MethodInterceptor、MethodProxy和Enhancer类
(1)、MethodInterceptor
MethodInterceptor类是方法拦截器，代理类实例的方法被调用时会回调MethodInterceptor的intercept()方法拦截，用来实现自己的代理逻辑，类似于jdk动态代理的InvocationHandler接口
(2)、MethodProxy
MethodProxy是intercept()方法中的第四个参数的类型，它是实际类方法的代理引用，使用methodProxy比使用jdk自身的method在效率上会有提升
(3)、Enhancer
Enhancer用来动态创建实际类子类的代理类实例，setSuperclass()方法设置实际类为父类，setCallback()方法建立方法回调，create()方法创建一个代理类实例

package com.wangxing.proxy3;


import java.lang.reflect.Method;

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

/**
 * 1.需要让生成代理类对象的java类实现MethodInterceptor接口
 * 2.重写MethodInterceptor接口的intercept方法
 * 3.创建生成代理对象的方法
 * @author Administrator
 *
 */
public class CreateDaiShouDianObject implements MethodInterceptor{
	 //定义目标对象[具体需要代理对象的java类]
	private Object targetObject;
	public  CreateDaiShouDianObject(Object targetObject){
		this.targetObject=targetObject;
	}
	//创建代理对象
	public  Object getProxyObject(){
		Enhancer  enhancer=new Enhancer();
		enhancer.setSuperclass(targetObject.getClass());
		enhancer.setCallback(this);
		return  enhancer.create();
	}
	//用来执行具体的代理动作
	@Override
	public Object intercept(Object proxy, Method method, Object[] arg2, MethodProxy methodproxy) throws Throwable {
		return methodproxy.invokeSuper(proxy, arg2);
	}
}

package com.wangxing.proxy3;
/**
 * 火车站
 * @author Administrator
 *
 */
public class HuoCheZhan {
	public void maipiao() {
		System.out.println("我家距离火车站近，我就出火车站买票");
	}
}

package com.wangxing.proxy3;

public class TestMain {

	public static void main(String[] args) {
		//根据家距离火车站的远近，决定去什么地方买票
		//家距离火车站近，选择火车站
		HuoCheZhan  hcz=new HuoCheZhan();
		hcz.maipiao();
		//家距离火车站远，选择代售点
		//创建火车站的代理对象
		CreateDaiShouDianObject  cpo=new CreateDaiShouDianObject(hcz);
		//得到代理对象
		HuoCheZhan  proxy=(HuoCheZhan)cpo.getProxyObject();
		proxy.maipiao();
	}

}

比较
1. 静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；
手动创建一个与目标类相同接口的子类，包装目标类。
2. JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；【兄弟模式】
通过jdk提供的反射包中Proxy这个类，动态的创建一个与目标类实现相同接口的子类对象，包装目标。
3. CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理。【父子模式】
通过CGlib提供的Enhancer这个类，动态的创建一个目标类的子类对象，包装目标类。

静态代理	jdk动态代理	CGlib动态代理
手动创建代理类	动态生成代理类对象	动态生成代理类对象
	jdk提供的反射包中Proxy这个类	CGlib提供的Enhancer这个类
	只能为实现过接口的Java类创建代理对象	为任何Java类创建代理对象

在这里插入图片描述

标签：package,class,代理,wangxing,---,javaSE,设计模式,com,public
来源： https://blog.csdn.net/sinat_50855580/article/details/112755089

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

javaSE---设计模式

认识设计模式

代理模式