一直想专门写个Spring源码的博客,工作了,可以全身性的投入到互联网行业中。虽然加班很严重,但是依然很开心。趁着凌晨有时间,总结总结。
首先spring,相信大家都很熟悉了。
1、轻量级 零配置,API使用简单
2、面向Bean 只需要编写普通的Bean(一个Bean代表一个对象)
3、松耦合 充分利用AOP思想 )(各自可以独立开发,然后整合起来运行)
4、万能胶 与主流框架无缝集成 (Mybatis dubbo等等 )
5、设计模式 将Java中经典的设计模式运用的淋漓尽致
Spring解决企业级应用开发的负责设计,简化开发。
1,基于POJO的清理爱你国际和最小侵入性(代码的嵌套,独自开发合起来运行)
2,通过依赖注入和面向接口松耦合
3、基于切面(典型的事务管理!!日志)和惯性进行声明式编程
4、通过切面和模板减少版式代码
主要通过,面向Bean、依赖注入以及面向切面三种方式达成
Spring提供了IOC容器,通过配置文件或者注解的方式来管理对象之间的依赖关系
A a = new A()//实例化后用一个变量保存下来(匿名对象) ------------------》Spring用IOC容器 存储起来~
a.c() //必须初始化才运行 -----------------------> Spring帮忙初始化,实例化(控制器给了spring)
最终实现了 依赖注入:
@autowrite Interfa A a //自动吧他的实现类注入进来
@Resource(“aa”)//IOC容器种类的id为“aa”的对象自动注入到这里
@autowrite A a //根据类型自动注入
Spring的注入方式
1、 setter
2、 构造方法
3、强制赋值
面向切面,AOP核心思想--解耦! 把一个整体拆开,分别开发,发布时候,再组装到一起运行,切面就是规则!
比如 事务;
开启事务 执行事务 事务回滚 关闭事务 这就是规则!!!!!!
这种有规律的,就可以认为他是固定的,可以单独拿出来开发设计,作为一个模块(比如日志啊)。
AOP就是个编程思想而已
关于Spring的使用,特点,网上资料很多,大家可以自己找找学习下。本博客主要对于源码进行解读。
在典型的面型对象开发方式中,可能要将日志记录语句放在所有方法和Java类种才能实现日志功能。而在AOP方式中,可以反过来将日志服务模块化,并以声明的方式将他们应用到需要日志的组件上。Java类不需要知道日志服务的存在,也不想需要考虑相关的代码。
AOP的功能完全集成到了Spring事务管理、日志和其他各种特性的上下文中
authentication权限认证
Logging日志
Transctions Manager事务
Lazy Loading懒加载
Contex Process 上下文处理
Error Handler 错误跟踪(异常捕获机制)
Cache缓存
1、除了AOP以外的设计模式
a、 代理模式
b、工厂模式
c、单例模式
d、委派模式
e、策略模式
f、策略模式
g、原型模式
代理模式原理:
1、拿到被代理对象的引用,然后获取它的接口
2、JDK代理重新生成一个类,同时实现我们给的代理对象所实现的接口
3、把代理对象的引用拿到
4、重新动态生成一个class字节码
5、编译
动态代理 调用哪个方法就代理哪个方法
整个类 生成一个新 的类
大家认真仔细研究好代理模式,代理模式在Spring中 应用非常广泛!!!
JDK代理模式实现:
1、定义接口
2、定义实现接口的类
3、 代理类 ,代理类需要实现 InvocationHandler 接口,然后实现 invoke方法
回顾一下,满足代理模式应用场景的三个必要条件,穷取法 1、两个角色:执行者、被代理对象 2、注重过程,必须要做,被代理对象没时间做或者不想做(怕羞羞),不专业 3、执行者必须拿到被代理对象的个人资料(执行者持有被代理对象的引用)
例:定义Persion接口
public interface Person { //寻找真爱、相亲 void findLove(); // String getSex(); // // String getName(); }
实现这个接口
//小星星、单身public class XiaoXingxing implements Person{ // private String sex = "女";// private String name = "小星星"; @Override public void findLove() {// System.out.println("我叫" + this.name + ",性别:" + this.sex + "我找对象的要求是:"); System.out.println("高富帅"); System.out.println("有房有车的"); System.out.println("身高要求180cm以上,体重70kg"); } // public String getSex() {// return sex;// }//// public void setSex(String sex) {// this.sex = sex;// }//// public String getName() {// return name;// }//// public void setName(String name) {// this.name = name;// } }
代理类
//媒婆 public class Meipo implements InvocationHandler { private Person target; //被代理对象的引用作为一个成员变量保存下来了 在下面调用时候的 的 ///////////////////////// 下面的嗲用 //获取被代理人的个人资料为,为了能让他代理任何对象 public Object getInstance(Person target) throws Exception { this.target = target; Class clazz = target.getClass(); //利用反射机制(最终获得接口) System.out.println("被代理对象的class是:" + clazz); return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this); //this这个参数 指的是 代理人 this.h 就是调用了媒婆的 invoke方法 this指的是invoke这个回调方法 } //代理对象 会自动调用下面invoke方法 @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable{ System.out.println("我是媒婆:" + "得给你找个异性才行"); System.out.println("开始进行海选..."); System.out.println("------------"); /////////////////////////////////////////////////////////// //调用的时候 (利用反射机制调用) 对象名.方法名 method.invoke(this.target, args); 这个invoke不是方法名字的invoke 是的话 会陷入死循环 System.out.println("------------"); System.out.println("如果合适的话,就准备办事"); return null; } }
测试:
public class TestFindLove { public static void main(String[] args) { try { // // Person obj = (Person)new Meipo().getInstance(new XiaoXingxing()); // System.out.println(obj.getClass()); // obj.findLove(); //原理: //1.拿到被代理对象的引用,然后获取它的接口 //2.JDK代理重新生成一个类,同时实现我们给的代理对象所实现的接口 //3.把被代理对象的引用也拿到了 //4.重新动态生成一个class字节码 //5.然后编译 //获取字节码内容 // byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class}); //生成字节码文件 // FileOutputStream os = new FileOutputStream("E:/GP_WORKSPACE/$Proxy0.class"); //将字节码输入到磁盘上 // os.write(data); // os.close(); //是什么? //为什么? //怎么做? //解释: 字节码 反编译后 可以查看 Person obj = (Person)new GPMeipo().getInstance(new XiaoXingxing()); //返回一个代理对象 代理出来的这个对象可以强转这个接口类 System.out.println(obj.getClass()); //这个Object对象 并不是 lcy的引用了 完全是一个新的对象 obj.findLove(); //动态代理 需要调用哪个方法 就调用哪个方法 整个类都是新的类了 新的字节码 } catch (Exception e) { e.printStackTrace(); } } }
也可以不用 JDK的任何东西 自己实现动态代理!!
不用jdk的任何东西!
首先规定有个InvocationHandler 有个 invoke方法
import java.lang.reflect.Method; public interface GPInvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }
实现个Proxy 里面有 InvocationHandler引用 有 newInstance的方法 classloader方法
import java.io.File; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import javax.tools.JavaCompiler; import javax.tools.JavaCompiler.CompilationTask; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; //生成代理对象的代码 public class GPPorxy { private static String ln = "\r\n"; public static Object newProxyInstance(GPClassLoader classLoader,Class<?>[] interfaces,GPInvocationHandler h){ try{ //1、生成源代码 String proxySrc = generateSrc(interfaces[0]); //2、将生成的源代码输出到磁盘,保存为.java文件 String filePath = GPPorxy.class.getResource("").getPath(); File f = new File(filePath + "$Proxy0.java"); FileWriter fw = new FileWriter(f); fw.write(proxySrc); fw.flush(); fw.close(); //3、编译源代码,并且生成.class文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null); Iterable iterable = manager.getJavaFileObjects(f); CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable); task.call(); manager.close(); //4.将class文件中的内容,动态加载到JVM中来 //5.返回被代理后的代理对象 Class proxyClass = classLoader.findClass("$Proxy0"); Constructor c = proxyClass.getConstructor(GPInvocationHandler.class); //拿到构造方法 f.delete(); return c.newInstance(h); }catch (Exception e) { e.printStackTrace(); } return null; } private static String generateSrc(Class<?> interfaces){ StringBuffer src = new StringBuffer(); src.append("package com.gupaoedu.vip.custom;" + ln); src.append("import java.lang.reflect.Method;" + ln); src.append("public class $Proxy0 implements " + interfaces.getName() + "{" + ln); src.append("GPInvocationHandler h;" + ln); src.append("public $Proxy0(GPInvocationHandler h) {" + ln); src.append("this.h = h;" + ln); src.append("}" + ln); for (Method m : interfaces.getMethods()) { //那么多方法 需要拿出来 src.append("public " + m.getReturnType().getName() + " " + m.getName() + "(){" + ln); src.append("try{" + ln); src.append("Method m = " + interfaces.getName() + ".class.getMethod(\"" +m.getName()+"\",new Class[]{});" + ln); //方法名 参数等等 src.append("this.h.invoke(this,m,null);" + ln); src.append("}catch(Throwable e){e.printStackTrace();}" + ln); src.append("}" + ln); } src.append("}"); return src.toString(); } }
classloader类
import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; //代码生成、编译、重新动态load到JVM public class GPClassLoader extends ClassLoader{ private File baseDir; public GPClassLoader(){ String basePath = GPClassLoader.class.getResource("").getPath(); this.baseDir = new java.io.File(basePath); //保存路径 } @Override protected Class<?> findClass(String name) throws ClassNotFoundException { String className = GPClassLoader.class.getPackage().getName() + "." + name; //找到这个class文件 if(baseDir != null){ File classFile = new File(baseDir,name.replaceAll("\\.", "/") + ".class"); if(classFile.exists()){ FileInputStream in = null; ByteArrayOutputStream out = null; try{ in = new FileInputStream(classFile); out = new ByteArrayOutputStream(); byte [] buff = new byte[1024]; //缓冲区 int len; while ((len = in.read(buff)) != -1) { out.write(buff, 0, len); } //全部读完 return defineClass(className, out.toByteArray(), 0,out.size()); //搞到jvm中去 }catch (Exception e) { e.printStackTrace(); }finally{ if(null != in){ try { in.close(); } catch (IOException e) { e.printStackTrace(); } } if(null != out){ try { out.close(); } catch (IOException e) { e.printStackTrace(); } } classFile.delete(); } } } return null; } }
代理类媒婆 必须实现这个类
import java.lang.reflect.Method; import com.gupaoedu.vip.proxy.jdk.Person; public class GPMeipo implements GPInvocationHandler{ private Person target; //获取被代理人的个人资料 public Object getInstance(Person target) throws Exception{ this.target = target; Class clazz = target.getClass(); System.out.println("被代理对象的class是:"+clazz); return GPPorxy.newProxyInstance(new GPClassLoader(), clazz.getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("我是媒婆:得给你找个异性才行"); System.out.println("开始进行海选..."); System.out.println("------------"); method.invoke(this.target, args); System.out.println("------------"); System.out.println("如果合适的话,就准备办事"); return null; } }
注意 Java中 $符号的 约定俗成 被代理的类
JDK 必须 实现接口!!!!
满足代理模式应用场景的三个必要条件,
1、需要有两个角色 执行者 和 被代理对象
2、注重过程,必须要做,被代理对象不做
3、执行者必须拿到被代理对象的资料(执行者持有被代理对象的引用)
代理模式总结到底层就是:字节码重组! (字节码重组时候 对象要强制转换,必须要实现一个接口)
Java源代码--->编译---->字节码(在原始的加了东西)-->加载到jvm中
然后 cglib不需要,Spring主要用的cglib做动态代理 定义一个类 自动生成一个类 自动继承这个类 子类引用指向父类 看下面:
(同样做了字节码重组 事情)
是继承关系
public class YunZhongYu { public void findLove(){ System.out.println("肤白貌美大长腿"); } }
定义代理类:
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 GPMeipo implements MethodInterceptor{ // MethodInterceptor这是cglib里面的 //疑问? //好像并没有持有被代理对象的引用 public Object getInstance(Class clazz) throws Exception{ //通过反射机制进行实例化 Enhancer enhancer = new Enhancer(); //用来动态生成class //把父类设置为谁? //这一步就是告诉cglib,生成的子类需要继承哪个类 enhancer.setSuperclass(clazz); //设置回调 enhancer.setCallback(this); //业务逻辑 指的是下面的 intercept 回调方法 //第一步、生成源代码 //第二步、编译成class文件 //第三步、加载到JVM中,并返回被代理对象 return enhancer.create(); } //同样是做了字节码重组这样一件事情 //对于使用API的用户来说,是无感知 @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { //要干的哪些事情 obj是生成以后的子类的引用 调用子类的引用就会调用这个子 intercept方法 调用super方法 System.out.println("我是GP媒婆:" + "得给你找个异性才行"); System.out.println("开始进行海选..."); System.out.println("------------"); //这个obj的引用是由CGLib给我们new出来的 //cglib new出来以后的对象,是被代理对象的子类(继承了我们自己写的那个类) //OOP, 在new子类之前,实际上默认先调用了我们super()方法的, //new了子类的同时,必须先new出来父类,这就相当于是间接的持有了我们父类的引用 //子类重写了父类的所有的方法 //我们改变子类对象的某些属性,是可以间接的操作父类的属性的 proxy.invokeSuper(obj, args); //可以直接调用 调用的是父类哦 System.out.println("------------"); System.out.println("如果合适的话,就准备办事"); return null; } }
测试类
public class TestGglibProxy { public static void main(String[] args) { //JDK的动态代理是通过接口来进行强制转换的 //生成以后的代理对象,可以强制转换为接口 //CGLib的动态代理是通过生成一个被代理对象的子类,然后重写父类的方法 //生成以后的对象,可以强制转换为被代理对象(也就是用自己写的类) //子类引用赋值给父类 try { YunZhongYu obj = (YunZhongYu)new GPMeipo().getInstance(YunZhongYu.class); //面向接口 对外开放 制定规范 接口就是规范 一般是是字符串 包名 类名 方法名之类的 obj.findLove(); } catch (Exception e) { e.printStackTrace(); } } }
代理可以实现 在每一个方法调用之前加一些代码,方法嗲用之后加一些代码
AOP: 事务代理、 日志监听
Service方法 开启一个事务 事务的执行是由我们自己的代码完成的
1、监听到是否有异常,可能需要根据异常的类型来决定这个事务是否好回滚or继续提交?(commit or rollback?)
2、事务要关闭掉
通过动态代理给加了代码
-------------------------------------工厂模式
首先要区分 生产者 消费者 消费者不关心工厂、过程 只关心结果 从工厂取东西哈哈
简单工厂:
定义接口:
//产品接口 //汽车需要满足一定的标准 public interface Car { //规定汽车的品牌 String getName(); }
实现之:
public class Bmw implements Car{ @Override public String getName() { return "BMW"; } }
public class Benz implements Car{ @Override public String getName() { return "Benz"; } }
public class Audi implements Car{ @Override public String getName() { return "Audi"; } }
定义工厂类
import com.gupaoedu.vip.factory.Audi; import com.gupaoedu.vip.factory.Benz; import com.gupaoedu.vip.factory.Bmw; import com.gupaoedu.vip.factory.Car; //对于这个工厂来说(太强大了) //为什么? //这个工厂啥都能干(不符合现实) //编码也是一种艺术(融汇贯通),艺术来源于生活,回归到生活的 public class SimpleFactory { //实现统一管理、专业化管理 //如果没有工厂模式,小作坊,没有执行标准的 //如果买到三无产品(没有标准) //卫生监督局工作难度会大大减轻 //中国制造(按人家的标准执行) //中国制造向中国创造改变(技术不是问题了,问题是什么?思维能力) //码农就是执行标准的人 //系统架构师,就是制定标准的人 //不只做一个技术者,更要做一个思考者 public Car getCar(String name){ if("BMW".equalsIgnoreCase(name)){ //Spring中的工厂模式 //Bean //BeanFactory(生成Bean) //单例的Bean //被代理过的Bean //最原始的Bean(原型) //List类型的Bean //作用域不同的Bean //getBean //非常的紊乱,维护困难 //解耦(松耦合开发) return new Bmw(); }else if("Benz".equalsIgnoreCase(name)){ return new Benz(); }else if("Audi".equalsIgnoreCase(name)){ return new Audi(); }else{ System.out.println("这个产品产不出来"); return null; } } }
测试类(消费者)
public class SimpleFactoryTest { public static void main(String[] args) { //这边就是我们的消费者 Car car = new SimpleFactory().getCar("Audi"); System.out.println(car.getName()); } }
接下来是 工厂方法模式
定义工厂接口
实现不同工厂
消费者使用
1、定义工厂接口
import com.gupaoedu.vip.factory.Car; //工厂接口,就定义了所有工厂的执行标准 public interface Factory { //符合汽车上路标准 //尾气排放标准 //电子设备安全系数 //必须配备安全带、安全气囊 //轮胎的耐磨程度 Car getCar(); }
2、实现这个工厂接口
import com.gupaoedu.vip.factory.Bmw; import com.gupaoedu.vip.factory.Car; public class BmwFactory implements Factory { @Override public Car getCar() { return new Bmw(); } }
import com.gupaoedu.vip.factory.Benz; import com.gupaoedu.vip.factory.Car; public class BenzFactory implements Factory { @Override public Car getCar() { return new Benz(); } }
3、测试类
public class FactoryTest { public static void main(String[] args) { //工厂方法模式 //各个产品的生产商,都拥有各自的工厂 //生产工艺,生成的高科技程度都是不一样的 Factory factory = new AudiFactory(); System.out.println(factory.getCar()); //需要用户关心,这个产品的生产商 factory = new BmwFactory(); System.out.println(factory.getCar()); //增加的代码的使用复杂度 //抽象工厂模式 } }
改进版的工厂方法模式,抽象工厂模式:
这个不再是 接口了 而是 抽象类
抽象类可以引用自己的方法!
默认的方法
import com.gupaoedu.vip.factory.Car; public class DefaultFactory extends AbstractFactory { private AudiFactory defaultFactory = new AudiFactory(); public Car getCar() { return defaultFactory.getCar(); } }
工厂方法
import com.gupaoedu.vip.factory.Car; public abstract class AbstractFactory { protected abstract Car getCar(); //这段代码就是动态配置的功能 //固定模式的委派 public Car getCar(String name){ if("BMW".equalsIgnoreCase(name)){ return new BmwFactory().getCar(); }else if("Benz".equalsIgnoreCase(name)){ return new BenzFactory().getCar(); }else if("Audi".equalsIgnoreCase(name)){ return new AudiFactory().getCar(); }else{ System.out.println("这个产品产不出来"); return null; } } }
import com.gupaoedu.vip.factory.Audi; import com.gupaoedu.vip.factory.Car; //具体的业务逻辑封装 public class AudiFactory extends AbstractFactory { @Override public Car getCar() { return new Audi(); } }
public class BenzFactory extends AbstractFactory { @Override public Car getCar() { return new Benz(); } }
public class BmwFactory extends AbstractFactory { @Override public Car getCar() { return new Bmw(); } }
单例模式:
整个系统从启动到终止,自会有一个实例
在应用中遇到功能性冲突的时候,需要用到单例模式
单例模式有7种写 法!!!
1.
1 public class Singleton implements java.io.Serializable { 2 public static Singleton INSTANCE = new Singleton(); 3 protected Singleton() { } 4 private Object readResolve() { 5 return INSTANCE; 6 } 7 }
2、
//懒汉式单例类.在第一次调用的时候实例化自己 public class Singleton1 { //1、第一步先将构造方法私有化 private Singleton1() {} //2、然后声明一个静态变量保存单例的引用 private static Singleton1 single = null; //3、通过提供一个静态方法来获得单例的引用 //不安全的 public static Singleton1 getInstance() { if (single == null) { single = new Singleton1(); } return single; } }
3、
//懒汉式单例.保证线程安全 public class Singleton2 { //1、第一步先将构造方法私有化 private Singleton2() {} //2、然后声明一个静态变量保存单例的引用 private static Singleton2 single=null; //3、通过提供一个静态方法来获得单例的引用 //为了保证多线程环境下正确访问,给方法加上同步锁synchronized //慎用 synchronized 关键字,阻塞,性能非常低下的 //加上synchronized关键字以后,对于getInstance()方法来说,它始终单线程来访问 //没有充分利用上我们的计算机资源,造成资源的浪费 public static synchronized Singleton2 getInstance() { if (single == null) { single = new Singleton2(); } return single; } }
4、
//懒汉式单例.双重锁检查 public class Singleton3 { //1、第一步先将构造方法私有化 private Singleton3() {} //2、然后声明一个静态变量保存单例的引用 private static Singleton3 single=null; //3、通过提供一个静态方法来获得单例的引用 //为了保证多线程环境下的另一种实现方式,双重锁检查 //性能,第一次的时候 public static Singleton3 getInstance() { if (single == null) { synchronized (Singleton3.class) { if (single == null) { single = new Singleton3(); } } } return single; } }
5、
//懒汉式(静态内部类) //这种写法,即解决安全问题,又解决了性能问题 //这个代码,没有浪费一个字 public class Singleton4 { //1、先声明一个静态内部类 //private 私有的保证别人不能修改 //static 保证全局唯一 private static class LazyHolder { //final 为了防止内部误操作,代理模式,GgLib的代理模式 private static final Singleton4 INSTANCE = new Singleton4(); } //2、将默认构造方法私有化 private Singleton4 (){} //相当于有一个默认的public的无参的构造方法,就意味着在代码中随时都可以new出来 //3、同样提供静态方法获取实例 //final 确保别人不能覆盖 public static final Singleton4 getInstance() { //方法中的逻辑,是要在用户调用的时候才开始执行的 //方法中实现逻辑需要分配内存,也是调用时才分配的 return LazyHolder.INSTANCE; } // static int a = 1; // //不管该class有没有实例化,static静态块总会在classLoader执行完以后,就加载完毕 // static{ // //静态块中的内容,只能访问静态属性和静态方法 // //只要是静态方法或者属性,直接可以用Class的名字就能点出来 // Singleton4.a = 2; // //JVM 内存中的静态区,这一块的内容是公共的 // } } //我们所写的所有的代码,在java的反射机制面前,都是裸奔的 //反射机制是可以拿到private修饰的内容的 //我们可以理解成即使加上private也不靠谱(按正常套路出牌,貌似可以) //类装载到JVM中过程 //1、从上往下(必须声明在前,使用在后) //先属性、后方法 //先静态、后动态
6、
//类似Spring里面的方法,将类名注册,下次从里面直接获取。 public class Singleton6 { private static Map<String,Singleton6> map = new HashMap<String,Singleton6>(); static { Singleton6 single = new Singleton6(); map.put(single.getClass().getName(), single); } //保护的默认构造子 protected Singleton6(){} //静态工厂方法,返还此类惟一的实例 public static Singleton6 getInstance(String name) { if(name == null) { name = Singleton6.class.getName(); } if(map.get(name) == null) { try { map.put(name, (Singleton6) Class.forName(name).newInstance()); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } return map.get(name); } }
测试类
public class TestMain { public static void main(String[] args){ TestSingleton ts1 = TestSingleton.getInstance(); ts1.setName("james"); TestSingleton ts2 = TestSingleton.getInstance(); ts2.setName("tom"); ts1.printInfo(); ts2.printInfo(); if(ts1 == ts2){ System.out.println("创建的是同一个实例" + ts1.getName()); }else{ System.out.println("创建的不是同一个实例" + ts1.getName()); } } }
public class TestSingleton { String name = null; private TestSingleton() {} //注意这里用到了volatile关键字 private static volatile TestSingleton instance = null; public static TestSingleton getInstance() { if (instance == null) { synchronized (TestSingleton.class) { if (instance == null) { instance = new TestSingleton(); } } } return instance; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void printInfo() { System.out.println("the name is " + name); } }
public class TestThread { public static void main(String[] args) { //启动100线程同时去抢CPU int count = 100; //发令枪,测试并发经常用到 CountDownLatch latch = new CountDownLatch(count); //Set默认去去重的,set是本身线程不安全的 // final Set<Singleton1> syncSet = Collections.synchronizedSet(new HashSet<Singleton1>()); for (int i = 0; i < count; i++) { new Thread(){ @Override public void run() { syncSet.add(Singleton1.getInstance()); } }.start(); latch.countDown(); } try { latch.await();//等待所有线程全部完成,最终输出结果 System.out.println(syncSet.size()); } catch (InterruptedException e) { e.printStackTrace(); } } }
委派模式:
1类似中介的功能(委托机制)
2只有被委托人的引用
两个角色 受托人 委托人
定义一个接口
public class Dispatcher implements IExector{ IExector exector; Dispatcher(IExector exector){ this.exector = exector; } //项目经理,虽然也有执行方法 //但是他的工作职责是不一样的 public void doing() { this.exector.doing(); } }
两个员工类实现这个接口
public class ExectorA implements IExector { @Override public void doing() { System.out.println("xxoo"); } }
public class ExectorB implements IExector{ @Override public void doing() { System.out.println("员工B开始执行任务"); } }
项目经理类
public class Dispatcher implements IExector{ IExector exector; Dispatcher(IExector exector){ this.exector = exector; } //项目经理,虽然也有执行方法 //但是他的工作职责是不一样的 public void doing() { this.exector.doing(); } }
测试
public class DispatcherTest { public static void main(String[] args) { Dispatcher dispatcher = new Dispatcher(new ExectorA()); //看上去好像是我们的项目经理在干活 //但实际干活的人是普通员工 //这就是典型,干活是我的,功劳是你的 dispatcher.doing(); } }
IOC容器中,有一个Register的东西(为了告诉我们的容器,在这个类被初始化的过程中,需要做很多不同的逻辑处理,需要实现多个任务执行者,分别实现各自的功能 )
关于策略模式,参考系 Comparator方法就可以啦 返回 -1 0 1这种的
a、比较器接口
b、调用时候有自己的实现
//比较器 public interface Comparator { int compareTo(Object obj1,Object obj2); }
public class ObjectComparator implements Comparator{ @Override public int compareTo(Object obj1, Object obj2) { return 0; } }
public class NumberComparator implements Comparator{ @Override public int compareTo(Object obj1, Object obj2) { return 0; } }
public class MyList { public void sort(Comparator com){ // com.compareTo(obj1, obj2); System.out.println("执行逻辑"); } }
public class MyListTest { public static void main(String[] args) { //new MyList().sort(new NumberComparator()); //策略模式 // List<Long> numbers = new ArrayList<Long>(); // // Collections.sort(numbers, new Comparator<Long>() { // // @Override // //返回值是固定的 // //0 、-1 、1 // //0 、 >0 、<0 // public int compare(Long o1, Long o2) { // // //中间逻辑是不一样的 // // return 0; // } // // // }); } }
原型模式:
首先要设计个原型
实现 Cloneable接口
public class ConcretePrototype implements Cloneable{ private int age; private String name; public ArrayList<String> list = new ArrayList<String>(); protected Object clone() throws CloneNotSupportedException { ConcretePrototype prototype = null; try{ prototype = (ConcretePrototype)super.clone(); prototype.list = (ArrayList)list.clone(); //克隆基于字节码的 //用反射,或者循环 }catch(Exception e){ } return prototype; } //定义上100个属性 public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
public class CloneTest { public static void main(String[] args) { ConcretePrototype cp = new ConcretePrototype(); cp.setAge(18); cp.setName("Tom"); //cp.list.add("Tom"); try { ConcretePrototype copy = (ConcretePrototype)cp.clone(); System.out.println(copy.list == cp.list); System.out.println(copy.getAge() + "," + copy.getName() + copy.list.size()); } catch (CloneNotSupportedException e) { e.printStackTrace(); } //就是一个现成的对象,这个对象里面有已经设置好的值 //当我要新建一个对象,并且要给新建的对象赋值,而且赋值内容要跟之前的一模一样 //ConcretePrototype cp = new ConcretePrototype(); //cp.setAge(18); //ConcretePrototype copy = new ConcretePrototype(); //copy.setAge(cp.getAge()); //copy.setName(cp.getName()); //用循环,用反射,确实可以的(反射性能并不高) //字节码复制newInstance() //ConcretePrototype copy = cp; //ORM的时候经常用到的 //能够直接拷贝其实际内容的数据类型/只支持9种,八大基本数据类型+String 浅拷贝 //深拷贝 } }
原型模式:
//猴子 public class Monkey { //身高 protected int height;//基本 //体重 protected int weight; //生日 protected Date birthday;//不是基本类型 public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public Date getBirthday() { return birthday; } public void setBirthday(Date birthday) { this.birthday = birthday; } }
public class TestPrototype { public static void main(String[] args) { TheGreatestSage sage = new TheGreatestSage(); sage.change(); //跟《西游记》中描述的一致,怎么办? } }
public class GoldRingedStaff implements Serializable{ private float height = 100; //长度 private float diameter = 10;//直径 /** * 金箍棒长大 */ public void grow(){ this.diameter *= 2; this.height *= 2; } /** * 金箍棒缩小 */ public void shrink(){ this.diameter /= 2; this.height /= 2; } }
/** * 齐天大圣 * */ public class TheGreatestSage extends Monkey implements Cloneable,Serializable{ //金箍棒 private GoldRingedStaff staff; //从石头缝里蹦出来 public TheGreatestSage(){ this.staff = new GoldRingedStaff(); this.birthday = new Date(); this.height = 150; this.weight = 30; System.out.println("------------------------"); } //分身技能 public Object clone(){ //深度克隆 ByteArrayOutputStream bos = null; ObjectOutputStream oos = null; ByteArrayInputStream bis = null; ObjectInputStream ois = null; try { //return super.clone();//默认浅克隆,只克隆八大基本数据类型和String //序列化 bos = new ByteArrayOutputStream(); oos = new ObjectOutputStream(bos); oos.writeObject(this); //反序列化 bis = new ByteArrayInputStream(bos.toByteArray()); ois = new ObjectInputStream(bis); TheGreatestSage copy = (TheGreatestSage)ois.readObject(); copy.birthday = new Date(); return copy; } catch (Exception e) { e.printStackTrace(); return null; }finally{ try { bos.close(); oos.close(); bis.close(); ois.close(); } catch (IOException e) { e.printStackTrace(); } } } //变化 public void change(){ TheGreatestSage copySage = (TheGreatestSage)clone(); System.out.println("大圣本尊生日是:" + this.getBirthday().getTime()); System.out.println("克隆大圣的生日是:" + copySage.getBirthday().getTime()); System.out.println("大圣本尊和克隆大圣是否为同一个对象:" + (this == copySage)); System.out.println("大圣本尊持有的金箍棒跟克隆大圣持有金箍棒是否为同一个对象:" + (this.getStaff() == copySage.getStaff())); } public GoldRingedStaff getStaff() { return staff; } public void setStaff(GoldRingedStaff staff) { this.staff = staff; } }
模板模式:
模板(固定的执行流程)
定义冲饮料的机器:
//冲饮料(拿出去卖钱了) public abstract class Bevegrage { //不能被重写 public final void create(){ //1、把水烧开 boilWater(); //2、把杯子准备好、原材料放到杯中 pourInCup(); //3、用水冲泡 brew(); //4、添加辅料 addCoundiments(); } public abstract void pourInCup(); public abstract void addCoundiments(); public void brew(){ System.out.println("将开水放入杯中进行冲泡"); }; public void boilWater(){ System.out.println("烧开水,烧到100度可以起锅了"); } }
实现为冲咖啡的
public class Coffee extends Bevegrage{ //原材料放到杯中 public void pourInCup() { System.out.println("将咖啡倒入杯中"); } //房辅料 public void addCoundiments() { System.out.println("添加牛奶和糖"); } }
实现为泡茶的
public class Tea extends Bevegrage{ //原材料放到杯中 public void pourInCup() { System.out.println("将茶叶放入杯中"); } //房辅料 public void addCoundiments() { System.out.println("添加蜂蜜"); } }
测试类
public class TestTemplate { public static void main(String[] args) { // Coffee coffee = new Coffee(); // coffee.create(); Tea tea = new Tea(); tea.create(); } //SpringJDBC //是java规范,各个数据库厂商自己去实现 //1、加载驱动类DriverManager //2、建立连接 //3、创建语句集(标准语句集、预处理语句集)(语句集? MySQL、Oracle、SQLServer、Access) //4、执行语句集 //5、结果集ResultSet 游标 //ORM(?) }
Spring JDBC就是个模板模式
是 Java的规范 各个数据库厂商去实现
1、加载驱动类 DriverManager
2、建立连接
3、创建语句集(标准语句集、预处理语句集)(语句集合? Mysql oracle sqlserver access 语句不太一样哦)
4、执行语句集
5、结果集ResultSet 游标
ORM (连接的是哪个对象 映射哪个结果 List or 自定义的类 还是??运行时候才知道)
https://www.cnblogs.com/toov5/p/9472082.html
原文地址:https://www.cnblogs.com/langtianya/p/10206884.html