- 博客(72)
- 收藏
- 关注
RSS订阅原创 spring cache
使用spring cache 时，需开启缓存注解使用缓存，还需要配置cacheManagercacheManager有很多实现类，对应不同的缓存框架spring cache 提供了几个注解，用于设置缓存@Cacheable该注解会将方法的返回值进行缓存，下次调用该方法，会取缓存中数据该注解可以放在类名上，也可以放在方法上value：指定CacheName，cacheNames:等同于valuekey：指定缓存keykeyGenerator:指定缓存key生成策略cacheManag
2022-07-03 14:23:49
319
原创 spring-定时任务
spring开启定时任务，需要注解EnableSchedulingImport注解中，有SchedulingConfiguration这个SchedulingConfiguration，会创建beanPostProcessor–ScheduledAnnotationBeanPostProcessor
2022-03-08 11:12:35
277
原创 spring aop
解析xml，解析aop标签，aop解析会进入parseCustomElement方法根据namespaceurl找到标签解析器configureAutoProxyCreator方法会注册org.springframework.aop.config.internalAutoProxyCreator ，取出aop标签中的属性，对beanDefinition进行属性添加。获取子标签，分别对pointcut、advisor，aspect进行解析解析aspect private void pars
2021-12-13 21:15:33
329
2
原创 spring bean的实例化
bean的实例化是spring中重要的一环，涉及了bean的生命周期。实例化方法主要在preInstantiateSingletons中首先获取beanName遍历beanName，根据beanName查出beanDefinition如果bean是单例，并且未设置懒加载，并且是不能被实例化的，则继续下面的判断：如果bean是factoryBean，则通过&+beanName 实例化并获取bean。如果不是，则通过beanName 实例化并获取bean实际获取bean的方法如果na
2021-12-05 15:55:57
1582
1
原创 spring invokeBeanFactoryPostProcessors方法
invokeBeanFactoryPostProcessors是spring容器的后置处理方法，beanFactoryPostProcessors是容器中已有的处理器，也就是这个list遍历这个list，如果processor是BeanDefinitionRegistry类型，调用其postProcessBeanDefinitionRegistry方法，并将该processor放入registryProcessors，否则processor仅是放入regularPostProcessors这
2021-11-29 22:27:46
380
原创 spring BeanDefinition加载过程（xml）
注：1.本文内容不是很细致，只能帮助大家了解个大概流程-_-||2.方法里会删减无关的内容spring beanDefinition加载，在方法obtainFreshBeanFactory中完成refreshBeanFactory方法createBeanFactory：创建容器，会获取parent容器作为参数传入loadBeanDefinition：先创建beanDefinitionReader获取resource，也就是配置的xml文件将resource读入，解析成document
2021-11-27 14:07:02
593
原创 spring boot
1.导入xml配置文件，可以用@ImportResource注解2.可以在@SpringBootApplication，@EnableAutoConfiguration注解中排除自动配置类@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})@SpringBootApplication(excludeName={类的全路径名})devtools添加maven依赖<dependencies> &l
2021-10-08 23:36:34
109
原创 jvm gc参数
垃圾回收方式标记清除将内存中存活的对象做标记，标记完成后清除那些没有标记的对象优点：简单高效缺点：存在内存碎片标记复制内存分为E、S两块，将E内存中存活的对象做标记，把这些存活的对象拷贝到内存S中，清除E内存优点：无内存碎片缺点：存在内存空间浪费，只能利用一块内存改进：内存分为E、S1、S2，其中E占80%，S1,S2各占10%，存活的对象拷贝到S1或S2中的某一块，只会浪费10%内存空间标记整理将内存中存活的对象做标记，标记完成后清除那些没有标记的对象，并定时整理内存优
2021-08-24 00:11:55
444
原创 dispatcherServlet
dispatchservlet执行流程获取请求对应的HandlerExecutionChain，并向其中添加拦截器 mappedHandler = getHandler(processedRequest); /* ** 去handlermapping中找到HandlerExecutionChain，根据路径 */ protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
2021-06-20 22:31:37
113
原创 java8流式操作
1.filter：对数据进行过滤，只会留下返回值为true的数据例：List<String> test = new ArrayList<>();test.add("tom");test.add("jerory");//过滤出值为tom的元素，生成新的流数据test.stream().filter(o->o.equals("tom"));2.map：对数据进行操作例：List<String> test = new ArrayList<>
2021-06-17 21:53:25
159
原创 maven
maven依赖范围scopecompile：默认配置，编译、运行、测试时都生效test：测试时生效provided：编译、测试时生效，runtime：测试、运行时生效import：用于导入其他依赖依赖冲突处理最短路径优先如果存在依赖 A -> B -> C(1.0)，D ->C(2.0)，因为 D ->C(2.0) 路径更短，所以会引入C（2.0）这个包最先声明原则如果存在依赖 A -> B -> C(1.0)，D ->F -> C(
2021-06-06 16:28:34
61
原创 redis 哨兵模式
哨兵之间通过主库上有一个名为“sentinel:hello”的频道，来相互发现，实现互相通信的。哨兵 给主库发送 INFO 命令，主库接受到这个命令后，就会把从库列表返回给哨兵。接着，哨兵就可以根据从库列表中的连接信息，和每个从库建立连接，并在这个连接上持续地对从库进行监控。数据丢失情况：异步复制master数据异步复制到slave过程中，如果master宕机，数据未同步完成，哨兵将slave节点选举为master，导致数据丢失。脑裂原有的master与slave、哨兵网络不连通，但仍对外
2021-04-05 22:46:55
129
原创 command模式
命令模式：将命令本身与命令的调用分离。command：命令接口，定义执行命令的方法executeconcreteCommand：具体的命令，持有实际命令执行的引用receiverReceiver：命令的实际执行者，例如遥控器可以操控电视，增加音量，减小音量，换台等。interface Command{ void execute();}class AddVolCommand interface Command{ YaoKongQi ykq; //命令的具体执行，是调用遥控器类中的addV
2021-03-10 23:04:45
88
原创 proxy模式
代理模式：不直接通过原有类调用，而是添加代理类进行调用。可以对外屏蔽原有类，其中原有类是不感知代理类的，并不知道是谁调用的，而代理类是感知原有类的，因为持有原有类的引用。例如我想买火车票，但是亲自去买，我嫌麻烦，就希望有人替我买。我不关心代理人手中的票是怎么来的，我只希望能从代理人那获得火车票。//定义买票接口interface Ticket{ void buy();}class People implements Ticket{ buy(){ //买票 }}class Proxy
2021-03-10 21:51:24
81
原创 flyweight模式
享元模式：通过共享对象，节省内存。例如可以创建对象缓存池，已经存在的对象无需创建，只需从缓存池中取出返回public Pool{ Map<String,Object>map=new HashMap(); Object createObject(String s){ //缓存中已有对象，无需创建 if(map.get(s)!=null) return s; else{ //创建对象，放入map Object o=new Object(); map.put(s
2021-03-08 22:44:31
140
原创 state模式
状态模式：用类来表示状态。例如客服电话，只有白天的时候才有人工服务，晚上就只有自助服务。如果没有状态类，通常代码实现是这样的：class Service{ public void server(){ if(白天){ 人工服务 } if(晚上){ 自助服务 } }}如果将白天、晚上用对象来表示，那么代码会是这样的//状态接口，定义服务方法interface State{ void server();}//白天类class Day implements S
2021-03-03 23:14:11
168
1
原创 memento模式
备忘录模式：通过保存状态对象，记录状态信息，将状态进行回退。例如单机游戏可以存档，可以回到某个存档点。class Player{ //玩家当前的武器 private String weapon; //玩家当前拥有的金钱 private String money; //创建存档 public State create(); //回复存档 public void restore(State state);}//存档状态class State{ private String weapo
2021-03-03 22:40:56
126
1
原创 观察者模式
观察者模式：被观察者在发生变化后，会通知观察者。例如你在微博上关注了一个明星，当明星发了一条新微博后，你就会收到通知。其中你是观察者，明星就是被观察者。//观察者接口interface Observer { void notify();}//被观察者类public class Observerd{ //观察者集合 List<Observer> observer; //添加观察者 public void add(Observer observer){ observer.
2021-03-02 21:22:21
73
原创 mediator模式
中介者模式：将类与类之间的调用关系，通过一个中间类来解耦。所有的类调用，都会通过中间类进行转发。例如有三个类，三个类需要相互通信，如果没有中介者，每个类里都要包含与其他类发送消息的方法。有了中介者后，发送消息的方法就可以只定义在中介者中，其他类只需要调用中介者的方法就可以了。class Mediator{ void sendA(Message msg){}; void sendB(Message msg){}; void sendC(Message msg){};}class A {//类里
2021-02-28 22:27:40
184
原创 facade模式
facade模式：将内部复杂的类关系，整合成一个统一对外的接口，就像银行柜台一样，有柜员给你提供服务，你不用了解内部是怎么流转的。Client：调用者类Facade：对外暴露的接口ClassA：提供具体服务的内部类AClassB：提供具体服务的内部类BClassC：提供具体服务的内部类CClassD：提供具体服务的内部类D...
2021-02-28 22:06:00
261
原创 责任链模式
责任链模式：定义多个处理类，组成处理链，每个类都是链路上的一个元素，对数据进行处理，如果当前元素处理不了，可以转交给下一个元素处理。例如给某个人转账，在手机上转账失败了，去自助机上转账，自助机上转账失败了，再去柜台转账。//转账抽象类public abstract class Transfer{ //持有下一个转账类对象，本类处理失败，就会发到下一个类上处理 private Transfer next; boolean trans(){ //如果当前类转账失败，就交给下一个类处理 if(!
2021-02-28 15:58:54
76
原创 visitor模式
访问者模式：数据结构与数据的访问分离，通过定义访问者类，对数据进行访问操作visitor：访问者接口，ListVisitor：具体的访问者，Element：定义接受访问者的接口acceptEntry：定义具体元素的接口File：具体的元素fileDirectory：具体的元素directory//访问者接口public abstract class Visitor{ public abstract void visitor(File file); public abstract voi
2021-02-28 15:39:34
148
原创 decorator模式
装饰模式：给对象添加装饰、添加功能。例如有一块蛋糕，添上草莓就是草莓蛋糕，添上巧克力就是巧克力蛋糕，本质都是蛋糕，就是装饰物不同。//定义蛋糕接口，interface Cake{ void print();}//具体的蛋糕，class ConcreteCake implements Cake{ void print(){ system.out.print("这是一个蛋糕") }}//抽象装饰类，继承蛋糕接口，与蛋糕类具有一致性abstract class Decorator im
2021-02-28 15:04:06
87
原创 composite模式
composite模式：容器本身与内部元素具有一致性，例如文件与文件夹的关系。Entry：文件和文件夹的抽象，使得file和directory具有一致性File：文件Directory：文件夹，可以存放文件
2021-02-27 12:11:26
210
原创 strategy模式
策略模式：针对同一功能，有不同的实现，可以对功能方法的实现进行替换。//排序功能定义interface Sort { //对arr数组进行排序 void sort(int []arr);}//冒泡排序class BubbleSort{ void sort(int[]arr){};}//归并排序class MergeSort{ void sort(int[]arr){};}...
2021-02-27 11:35:21
86
原创 bridge 模式
桥接模式：将类的功能实现与类的层次关系分离类的功能层次：如果需要新增功能，通常会继承原有的类，新写一个类，并添加新功能的实现，从而形成了类的功能层次关系。类的实现层次：如果要给类添加新的实现，比如说给水果类添加新的类，苹果，需要继承原来的水果类，新写一个苹果类，这样就形成了类之间的实现层次关系。例如显示器类，类的实现层次上，有各种各样的品牌显示器，类的功能实现上，显示器可以打开，关闭，调节等//定义显示器类class Monitor{ //持有功能层次接口的引用 MonitorFun impl
2021-02-27 11:11:57
97
原创 abstract factory 模式
抽象工厂模式：工厂将零件组合成一个产品例如组装一台电脑主机，需要cpu，主板、内存等零部件//零件类的抽象接口public abstract class Item{}//cpu零部件public abstract class CPU extends Item{}//主板零部件public abstract class Board extends Item{}//内存条零部件public abstract class Memory extends Item{}//零件工厂publ
2021-02-27 10:37:20
111
原创 builder模式
builder模式：对于复杂的对象创建，可以将创建过程封装为对象。abstractbuilder：抽象类，定义创建对象各个部分的方法concretebuilder：抽象类的具体实现，实现创建对象各个部分的细节例如盖房子，需要砌墙，装防盗门，装玻璃等，属于盖房子的一部分。class House(){ private String wall; private String door; private String glass; public void setWall(String wall){
2021-02-25 21:53:41
150
原创 prototype模式
原型模式：根据已有对象，来创建新的对象。client：用于注册、获取对象prototype：原型对象接口concreteprototype：具体的对象实现//原型对象接口interface Prototype{ //定义生成对象的方法 void clone()}//某一具体的原型对象class A implements Prototype { public void clone (){ //具体是怎么根据已有对象，来生成新对象的 }}class Client { //存储
2021-02-25 21:28:24
156
原创 singleton模式
单例模式：只生成一个实例单例模式的实现方式有多种1. class Singleton{ private static Singleton singleton=new Singleton(); //构造函数置为private，避免new的方式生成 private Singleton(){} //提供访问方法 public static getSingleton(){ return singleton; }}2.class Singleton{ //voliate 避免线程间看到的
2021-02-24 22:22:54
73
原创 工厂模式
工厂模式：产品由工厂生成，具体的产品由具体的工厂生成Factory中定义生成产品的方法，Product是产品接口。IDCardFactory是Factory的某一个具体实现，用来生成具体产品IDCard
2021-02-24 22:03:28
100
原创 模板模式
模板模式：接口中定义流程，具体的执行细节由子类实现。比如说把大象装进冰箱里，第一步打开冰箱，第二步放入大象，第三步关上冰箱。接口中定义这样的步骤，至于具体是怎么实现的，交给子类去实现。//定义步骤interface Template{ void open(); void put(); void close();}//实现步骤class A implement Template{ public void open(){ //打开冰箱，具体怎么打开，需要自己实现 } public
2021-02-24 21:48:25
75
原创 adapter模式
适配器模式：将原有的接口进行转换，达到复用的目的比如说我手头上有220v的充电器，但是当地只有110v的电压，无法直接使用。现在就需要一个中间的转换器，完成电压的转换(实际完成工作的，还是那个220v的充电器)。适配器模式有两种实现：1.继承 2.委托继承方式实现：//220v的充电器class Charger1 { //220v充电方法 void chargeWith220V();}//110v的充电器interface Charger2 { //110v充电方法 void
2021-02-23 22:46:13
125
原创 iterator模式
迭代器模式，将数据的遍历与数据分离，遍历数据集合与数据集合的实现不再关联。Aggregate：集合接口ConcreteAggregate：具体的集合实现Iterator：迭代器接口ConcreteIterator：具体的迭代器实现集合接口Aggregate内部会包含一个迭代器接口Iterator，迭代器接口中定义了hasNext、next 方法。hasNext方法用于判断元素是否遍历完成，nex方法t用于返回当前游标指向的元素，并将游标后移。遍历元素时，调用Iterator接口中的方法，与集
2021-02-23 22:07:29
109
原创 spring resource
resourcepublic interface InputStreamSource { //定位并打开资源，返回一个用于读取资源的InputStream。预期每次调用都会返回一个新的InputStream。调用者负责关闭流 InputStream getInputStream() throws IOException;}~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~public interfa
2021-01-27 23:43:00
82
原创 FileReader | FileWriter
FileReaderFileReader按字符读取文件，本身未实现任何read方法，通过调用继承的InputStreamReader中的read方法实现读取构造函数 public FileReader(File file) throws FileNotFoundException { //调用inputstreamreader的构造函数，进行初始化 super(new FileInputStream(file)); }FileWriterFileWriter 按字符写入
2020-12-30 10:07:32
105
原创 InputStreamReader
InputStreamReaderInputStreamReader可以将字节流转为字符流， 构造函数 public InputStreamReader(InputStream in) { //设置对象锁 super(in); try { //确定解码格式，分配缓冲区 sd = StreamDecoder.forInputStreamReader(in, this, (String)null); } ca
2020-12-29 17:15:32
575
原创 BufferedInputStream | BufferedOutputStream
BufferedInputStream 是一个包装类，通过持有inputstream的引用，并在原有read方法基础上添加buffer数组缓存，实现了缓冲的目的。构造函数，需要传入实际的inputstream，默认缓冲数组大小8192,8kb public BufferedInputStream(InputStream in) { this(in, DEFAULT_BUFFER_SIZE); }~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2020-12-25 14:54:43
232
1
原创 CopyOnWriteArrayList
CopyOnWriteArrayList 是一个线程安全的集合，读写分离，读不加锁，写时复制新数组，在新数组上操作。读取数据时，有可能读到旧数组中数据。如果对象元素很多，拷贝时会很占内存//构造函数，创建一个空数组 public CopyOnWriteArrayList() { setArray(new Object[0]); }~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2020-12-24 11:24:45
135
原创 LinkedBlockingQueue
LinkedBlockingQueue 是阻塞式的无界队列构造函数，初始化capacity为int最大值，创建头尾节点 public LinkedBlockingQueue() { this(Integer.MAX_VALUE); } public LinkedBlockingQueue(int capacity) { if (capacity <= 0) throw new IllegalArgumentException();
2020-12-23 11:39:53
169
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人