https://www.runoob.com/design-pattern/design-pattern-tutorial.html
1.什么是设计模式？
设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结
2.设计模式的作用是什么？
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
3.什么是单例模式/单态模式？
单例模式---保证一个类仅有一个实例。
当类被频繁地创建与销毁的时候，我们使用单例模式，这样可以减少了内存的开销，避免对资源的多重占用。
4.单例模式的两种表示方式以及区别
1、懒汉式
package com.wangxing.danli1;
/**
* 懒汉式
* 1.提供一个私有的构造方法
* 2.提供一个私有的静态成员变量，用于保存创建的对象
* 3.提供一个公共的静态方法，返回当前类的对象
* 4.为了保证在多线程的情况下当前类对象只有一个，我们就需要添加"synchronized[线程同步关键字]"
* @author Administrator
*
*/
public class DanLiDemo1 {
private DanLiDemo1(){}
private static DanLiDemo1 danli=null;
//为了保证在多线程情况下当前类对象只有一个我们就需要添加"synchronized[线程同步关键字]"
public static synchronized DanLiDemo1 getDanli(){
if(danli==null){
danli=new DanLiDemo1();
}
return danli;
}
}2.饿汉式
package com.wangxing.danli1;
/**
* 饿汉式
* 1.构造方法私有
* 2.提供一个私有静态成员变量，保存当前类对象
* 3.提供一个公共静态方法，返回当前类的对象
* 4.为了保证在多线程下该类的对象只有一个，就需要我们使用"synchronized[线程同步关键字]"
* @author Administrator
*
*/
public class DanLiDemo2 {
private DanLiDemo2(){}
private static DanLiDemo2 danli=new DanLiDemo2();
public static synchronized DanLiDemo2 getDanli(){
return danli;
}
}
package com.wangxing.danli1;
public class TestMain {
public static void main(String a[]){
//测试懒汉式的单例模式
DanLiDemo1 danli1=DanLiDemo1.getDanli();
DanLiDemo1 danli2=DanLiDemo1.getDanli();
DanLiDemo1 danli3=DanLiDemo1.getDanli();
if(danli1==danli3){
System.out.println("danli1等于danli3");
}
if(danli2.equals(danli3)){
System.out.println("danli2等于danli3");
}
if(danli1.hashCode()==danli2.hashCode()){
System.out.println("danli1等于danli2");
}
//测试饿汉式
DanLiDemo2 danli4=DanLiDemo2.getDanli();
DanLiDemo2 danli5=DanLiDemo2.getDanli();
if(danli4==danli5){
System.out.println("danli4等于danli5");
}
if(danli4.equals(danli5)){
System.out.println("danli4等于danli5");
}
if(danli4.hashCode()==danli5.hashCode()){
System.out.println("danli4等于danli5");
}
}
}
区别
|
|
懒汉式 |
饿汉式 |
| 资源利用率 |
好 |
差 |
| 运行速度 |
差 |
好 |
5.什么是工厂模式？
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
1.需求量大
2.牵一发，动全身
有3种角色
1.工厂角色----【普通类】
2.抽象产品角色---【抽象类/接口】
3.具体产品角色----【抽象类/接口子类】
例如:游戏中有各种角色，有战士，有刺客，有法师......
游戏---工厂角色----【类】
攻击---抽象产品角色---【抽象类/接口】
战士，刺客，法师---具体产品角色----【抽象类/接口子类】
抽象工厂模式---提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
6.如何编写简单工厂【静态】模式？
package com.wangxing.gongchang1;
/**
* 游戏角色接口
* @author Administrator
*
*/
public interface JueSe {
//所有角色具有的公共功能
void gongji();
}
package com.wangxing.gongchang1;
/**
* 法师类【具体产品】
* @author Administrator
*
*/
public class FaShi implements JueSe{
@Override
public void gongji() {
// TODO Auto-generated method stub
System.out.println("我是法师，使用魔杖");
}
}
package com.wangxing.gongchang1;
/**
* 刺客类【具体产品】
* @author Administrator
*
*/
public class CiKe implements JueSe{
@Override
public void gongji() {
// TODO Auto-generated method stub
System.out.println("我是刺客，使用匕首");
}
}
package com.wangxing.gongchang1;
/**
* 战士类【具体产品】
* @author Administrator
*
*/
public class ZhanShi implements JueSe{
@Override
public void gongji() {
// TODO Auto-generated method stub
System.out.println("我是战士，使用屠龙剑");
}
}
package com.wangxing.gongchang1;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.HashMap;
/**
* 工厂类 【生产角色对象】
* @author Administrator
*
*/
public class FactryClass {
//生产角色对象
public static JueSe getJuese(String name)throws Exception{
//读取 角色列表
JueSe js=null;
HashMap<String,String> jueseList=readJueSeListMap();
String classname=jueseList.get(name);
Class classobj=Class.forName(classname);
js=(JueSe)classobj.newInstance();
return js;
}
/**
* 读取角色列表
*/
private static HashMap<String,String> readJueSeListMap()throws Exception{
HashMap<String ,String> 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){
String jueseinfo[]=info.split("=");
jueselist.put(jueseinfo[0], jueseinfo[1]);
}
read.close();
in.close();
return jueselist;
}
}
package com.wangxing.gongchang1;
import java.util.Scanner;
public class TestMain {
public static void main(String args[])throws Exception{
Scanner input=new Scanner(System.in);
System.out.println("请输入角色名称");
String name=input.nextLine();
JueSe js=FactryClass.getJuese(name);
js.gongji();
}
}
7.什么是代理模式？
为其他对象提供一种代理以控制对这个对象的访问。
买火车票不一定在火车站买，也可以去代售点。
package com.wangxing.proxy1;
/**
* 提供售票业务的接口
* @author Administrator
*
*/
public interface ShouPiaoService {
void maipiao();
}
package com.wangxing.proxy1;
/**
* 火车站
* @author Administrator
*
*/
public class HuoCheZhan implements ShouPiaoService{
@Override
public void maipiao() {
// TODO Auto-generated method stub
System.out.println("我家离火车站近，我就去火车站买票");
}
}
package com.wangxing.proxy1;
/**
* 代售点
* @author Administrator
*
*/
public class DaiShouDian implements ShouPiaoService{
@Override
public void maipiao() {
// TODO Auto-generated method stub
System.out.println("我家里火车站远，我就去代售点");
}
}
package com.wangxing.proxy1;
public class TestMain {
public static void main(String arhs[]){
//根据家距离火车站的远近，决定去什么地方买票
//家距离火车站近，选择火车站
HuoCheZhan hcz=new HuoCheZhan();
hcz.maipiao();
//家距离火车站远，选择代售点
DaiShouDian dsd=new DaiShouDian();
dsd.maipiao();
}
}
上面这个实例中体现了静态代理，【兄弟模式的静态代理】
package com.wangxing.proxy2;
/**
* 提供售票业务的接口
* @author Administrator
*
*/
public interface ShouPiaoService {
void shoupiao();
}
package com.wangxing.proxy2;
/**
* 火车站
* @author Administrator
*
*/
public class HuoCheZhan implements ShouPiaoService{
@Override
public void shoupiao() {
// TODO Auto-generated method stub
System.out.println("我家距离火车站近，我就去火车站");
}
}
package com.wangxing.proxy2;
/**
* 代售点
* @author Administrator
*
*/
public class DaiShouDian extends HuoCheZhan{
@Override
public void shoupiao() {
// TODO Auto-generated method stub
System.out.println("我家距离火车站远，我就去代售点");
}
}
package com.wangxing.proxy2;
public class TestMain {
public static void main(String args[]){
HuoCheZhan hcz=new HuoCheZhan();
hcz.shoupiao();
DaiShouDian dsd=new DaiShouDian();
dsd.shoupiao();
}
}
上面这个实例中体现了静态代理，【父子模式的静态代理】
静态代理的缺点需要手动创建子类，当需要被代理元素较多的时候，我们的工作量变大了。
由于静态代理的上述缺点，所以我们需要一个专门生产代理对象的类
动态代理--专门由一个类来生产需要被代理的类的代理对象。
有2中方式
JDK动态代理----通过java.lang.reflect Class Proxy类来创建代理类对象。
【只能为实现过某个接口的java类提供代理类对象】
CGlib代理-------CGlib是一个第三发的开发包，用的时候需要自己事先下载导入到项目中
【所有的java类提供代理类对象】
8.JDK动态代理与CGlib代理的区别
JDK动态代理：
动态代理相比于静态代理，动态代理的代理类是在动态生成的，也就是jvm通过反射获取代码生成代理类，所以用户并不能决定代理角色和真实角色之间的联系，而是由程序运行时候决定的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。
动态代理实现的三步走：
1.实现InvocationHandler接口，创建自己的调用处理器 。
2.给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 。
3.执行真实角色具体任务。
要想创建处理器必须实现InvocationHandler接口，之后通过类装载器创建代理类。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy:指代我们所代理的那个真实对象
method:指代的是我们所要调用真实对象的某个方法的Method对象
args:指代的是调用真实对象某个方法时接受的参数
我们依旧要创建抽象角色和真实角色类
package com.wangxing.proxy3;
/**
* 提供售票业务的接口
* @author Administrator
*
*/
public interface ShouPiaoService {
void shoupiao();
}
package com.wangxing.proxy3;
/**
* 火车站
* @author Administrator
*
*/
public class HuoCheZhan implements ShouPiaoService{
@Override
public void shoupiao() {
// TODO Auto-generated method stub
System.out.println("我家距离火车站近，我就去火车站");
}
}
代理角色：和静态代理相比，静态代理运用对象调用完成代理，而动态代理通过实现InvocationHandler接口，创建了一个调用处理器，其实是通过Java的反射机制完成.
package com.wangxing.proxy3;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 1.需要让生成代理类对象的java类 实现InvocationHandler接口
* 2.重写InvocationHandler接口的invoke方法
* 3.创建生成代理对象的方法
* @author Administrator
*
*/
public class DongTaiDaiLi implements InvocationHandler{
//定义目标对象[具体需要代理对象的java类]
private Object dailiclass;
public DongTaiDaiLi(Object dailiclass){
this.dailiclass=dailiclass;
}
//通过java提供的proxy类创建出代理对象
public Object getProxyObject(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(), dailiclass.getClass().getInterfaces(), this);
}
//用来执行具体的代理动作
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
return method.invoke(dailiclass, args);
}
}
package com.wangxing.proxy3;
public class TestMain {
public static void main(String aegs[]){
HuoCheZhan hcz=new HuoCheZhan();
//hcz.shoupiao();
DongTaiDaiLi cpo=new DongTaiDaiLi(hcz);
ShouPiaoService proxy=(ShouPiaoService)cpo.getProxyObject();
proxy.shoupiao();
}
}
看上去实现很简单，我们只需要实现接口，调用其中的方法就可以实现动态代理。
通过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.proxy4;
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 CGlibDongTaiDaiLi implements MethodInterceptor{
//定义目标对象[具体需要代理对象的java类]
private Object dailiclass;
public CGlibDongTaiDaiLi(Object dailiclass){
this.dailiclass=dailiclass;
}
//创建代理对象
public Object getProxyObject(){
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(dailiclass.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
//用来执行具体的代理动作
@Override
public Object intercept(Object proxy, Method method, Object[] arg2, MethodProxy methodproxy) throws Throwable {
// TODO Auto-generated method stub
return methodproxy.invokeSuper(proxy,arg2);
}
}
package com.wangxing.proxy4;
public class HuoCheZhan {
public void maipiao(){
System.out.println("我家距离火车站近，我就去火车站买票");
}
}
package com.wangxing.proxy4;
public class TestMain {
public static void main(String args[]){
//根据加距离火车站的远近，决定去什么地方买票
HuoCheZhan hcz=new HuoCheZhan();
hcz.maipiao();
CGlibDongTaiDaiLi cglib=new CGlibDongTaiDaiLi(hcz);
HuoCheZhan proxy=(HuoCheZhan)cglib.getProxyObject();
proxy.maipiao();
}
}
比较
1.静态代理是通过在代码中显式定义一个业务实现类一个代理，在代理类中对同名的业务方法进行包装，用户通过代理类调用被包装过的业务方法；
手动创建一个与目标类相同接口的子类，包装目标类。
2.JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；【兄弟模式】
通过jdk提供的反射包中Proxy这个类，动态的创建一个与目标类实现相同接口的子类对象，包装目标。
3.CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理。【父子模式】
通过CGlib提供的Enhancer这个类，动态的创建一个目标类的子类对象，包装目标类。
| 静态代理 |
JDK动态代理 |
CGlib动态代理 |
| 手动创建代理类 |
动态生成代理类对象 |
动态生成代理类对象 |
|
|
jdk提供的反射包中Proxy这个类 |
CGlib提供的Enhancer这个类 |
|
|
只能为实现过接口的Java类创建代理对象 |
为任何Java类创建代理对象 |
