- 博客(72)
- 收藏
- 关注
RSS订阅原创 spring cache
使用spring cache 时，需开启缓存注解 使用缓存，还需要配置cacheManager cacheManager有很多实现类，对应不同的缓存框架 spring cache 提供了几个注解，用于设置缓存@Cacheable 该注解会将方法的返回值进行缓存，下次调用该方法，会取缓存中数据 该注解可以放在类名上，也可以放在方法上 value：指定CacheName， cacheNames:等同于value key：指定缓存key keyGenerator:指定缓存key生成策略 cacheManag
2022-07-03 14:23:49
382
原创 spring-定时任务
spring开启定时任务，需要注解EnableScheduling Import注解中，有SchedulingConfiguration 这个SchedulingConfiguration，会创建beanPostProcessor–ScheduledAnnotationBeanPostProcessor
2022-03-08 11:12:35
344
原创 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
401
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
1671
1
原创 spring invokeBeanFactoryPostProcessors方法
invokeBeanFactoryPostProcessors是spring容器的后置处理方法， beanFactoryPostProcessors是容器中已有的处理器， 也就是这个list 遍历这个list，如果processor是BeanDefinitionRegistry类型，调用其postProcessBeanDefinitionRegistry方法， 并将该processor放入registryProcessors，否则processor仅是放入regularPostProcessors 这
2021-11-29 22:27:46
447
原创 spring BeanDefinition加载过程（xml）
注：1.本文内容不是很细致，只能帮助大家了解个大概流程-_-|| 2.方法里会删减无关的内容 spring beanDefinition加载，在方法obtainFreshBeanFactory中完成 refreshBeanFactory方法 createBeanFactory：创建容器，会获取parent容器作为参数传入 loadBeanDefinition：先创建beanDefinitionReader 获取resource，也就是配置的xml文件 将resource读入，解析成document
2021-11-27 14:07:02
679
原创 spring boot
1.导入xml配置文件，可以用@ImportResource注解 2.可以在@SpringBootApplication，@EnableAutoConfiguration注解中排除自动配置类 @SpringBootApplication(exclude={DataSourceAutoConfiguration.class}) @SpringBootApplication(excludeName={类的全路径名}) devtools 添加maven依赖 <dependencies> &l
2021-10-08 23:36:34
157
原创 jvm gc参数
垃圾回收方式 标记清除 将内存中存活的对象做标记，标记完成后清除那些没有标记的对象 优点：简单高效 缺点：存在内存碎片 标记复制 内存分为E、S两块，将E内存中存活的对象做标记，把这些存活的对象拷贝到内存S中，清除E内存 优点：无内存碎片 缺点：存在内存空间浪费，只能利用一块内存 改进：内存分为E、S1、S2，其中E占80%，S1,S2各占10%，存活的对象拷贝到S1或S2中的某一块，只会浪费10%内存空间 标记整理 将内存中存活的对象做标记，标记完成后清除那些没有标记的对象，并定时整理内存 优
2021-08-24 00:11:55
539
原创 dispatcherServlet
dispatchservlet执行流程 获取请求对应的HandlerExecutionChain，并向其中添加拦截器 mappedHandler = getHandler(processedRequest); /* ** 去handlermapping中找到HandlerExecutionChain，根据路径 */ protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
2021-06-20 22:31:37
168
原创 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
234
原创 maven
maven依赖范围scope compile：默认配置，编译、运行、测试时都生效 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
102
原创 redis 哨兵模式
哨兵之间通过主库上有一个名为“sentinel:hello”的频道，来相互发现，实现互相通信的。 哨兵 给主库发送 INFO 命令，主库接受到这个命令后，就会把从库列表返回给哨兵。接着，哨兵就可以根据从库列 表中的连接信息，和每个从库建立连接，并在这个连接上持续地对从库进行监控。 数据丢失情况： 异步复制 master数据异步复制到slave过程中，如果master宕机，数据未同步完成，哨兵将slave节点选举为master，导致数据丢失。 脑裂 原有的master与slave、哨兵网络不连通，但仍对外
2021-04-05 22:46:55
182
原创 command模式
命令模式：将命令本身与命令的调用分离。 command：命令接口，定义执行命令的方法execute concreteCommand：具体的命令，持有实际命令执行的引用receiver Receiver：命令的实际执行者， 例如遥控器可以操控电视，增加音量，减小音量，换台等。 interface Command{ void execute(); } class AddVolCommand interface Command{ YaoKongQi ykq; //命令的具体执行，是调用遥控器类中的addV
2021-03-10 23:04:45
134
原创 proxy模式
代理模式：不直接通过原有类调用，而是添加代理类进行调用。可以对外屏蔽原有类，其中原有类是不感知代理类的，并不知道是谁调用的，而代理类是感知原有类的，因为持有原有类的引用。 例如我想买火车票，但是亲自去买，我嫌麻烦，就希望有人替我买。我不关心代理人手中的票是怎么来的，我只希望能从代理人那获得火车票。 //定义买票接口 interface Ticket{ void buy(); } class People implements Ticket{ buy(){ //买票 } } class Proxy
2021-03-10 21:51:24
131
原创 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
185
原创 state模式
状态模式：用类来表示状态。 例如客服电话，只有白天的时候才有人工服务，晚上就只有自助服务。 如果没有状态类，通常代码实现是这样的： class Service{ public void server(){ if(白天){ 人工服务 } if(晚上){ 自助服务 } } } 如果将白天、晚上用对象来表示，那么代码会是这样的 //状态接口，定义服务方法 interface State{ void server(); } //白天类 class Day implements S
2021-03-03 23:14:11
279
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
183
1
原创 观察者模式
观察者模式：被观察者在发生变化后，会通知观察者。 例如你在微博上关注了一个明星，当明星发了一条新微博后，你就会收到通知。其中你是观察者，明星就是被观察者。 //观察者接口 interface Observer { void notify(); } //被观察者类 public class Observerd{ //观察者集合 List<Observer> observer; //添加观察者 public void add(Observer observer){ observer.
2021-03-02 21:22:21
113
原创 mediator模式
中介者模式：将类与类之间的调用关系，通过一个中间类来解耦。所有的类调用，都会通过中间类进行转发。 例如有三个类，三个类需要相互通信，如果没有中介者，每个类里都要包含与其他类发送消息的方法。有了中介者后，发送消息的方法就可以只定义在中介者中，其他类只需要调用中介者的方法就可以了。 class Mediator{ void sendA(Message msg){}; void sendB(Message msg){}; void sendC(Message msg){}; } class A { //类里
2021-02-28 22:27:40
230
原创 facade模式
facade模式：将内部复杂的类关系，整合成一个统一对外的接口，就像银行柜台一样，有柜员给你提供服务，你不用了解内部是怎么流转的。 Client：调用者类 Facade：对外暴露的接口 ClassA：提供具体服务的内部类A ClassB：提供具体服务的内部类B ClassC：提供具体服务的内部类C ClassD：提供具体服务的内部类D ...
2021-02-28 22:06:00
319
原创 责任链模式
责任链模式：定义多个处理类，组成处理链，每个类都是链路上的一个元素，对数据进行处理，如果当前元素处理不了，可以转交给下一个元素处理。 例如给某个人转账，在手机上转账失败了，去自助机上转账，自助机上转账失败了，再去柜台转账。 //转账抽象类 public abstract class Transfer{ //持有下一个转账类对象，本类处理失败，就会发到下一个类上处理 private Transfer next; boolean trans(){ //如果当前类转账失败，就交给下一个类处理 if(!
2021-02-28 15:58:54
114
原创 visitor模式
访问者模式：数据结构与数据的访问分离，通过定义访问者类，对数据进行访问操作 visitor：访问者接口， ListVisitor：具体的访问者， Element：定义接受访问者的接口accept Entry：定义具体元素的接口 File：具体的元素file Directory：具体的元素directory //访问者接口 public abstract class Visitor{ public abstract void visitor(File file); public abstract voi
2021-02-28 15:39:34
198
原创 decorator模式
装饰模式：给对象添加装饰、添加功能。 例如有一块蛋糕，添上草莓就是草莓蛋糕，添上巧克力就是巧克力蛋糕，本质都是蛋糕，就是装饰物不同。 //定义蛋糕接口， interface Cake{ void print(); } //具体的蛋糕， class ConcreteCake implements Cake{ void print(){ system.out.print("这是一个蛋糕") } } //抽象装饰类，继承蛋糕接口，与蛋糕类具有一致性 abstract class Decorator im
2021-02-28 15:04:06
117
原创 composite模式
composite模式：容器本身与内部元素具有一致性，例如文件与文件夹的关系。 Entry：文件和文件夹的抽象，使得file和directory具有一致性 File：文件 Directory：文件夹，可以存放文件
2021-02-27 12:11:26
293
原创 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
120
原创 bridge 模式
桥接模式：将类的功能实现与类的层次关系分离 类的功能层次：如果需要新增功能，通常会继承原有的类，新写一个类，并添加新功能的实现，从而形成了类的功能层次关系。 类的实现层次：如果要给类添加新的实现，比如说给水果类添加新的类，苹果，需要继承原来的水果类，新写一个苹果类，这样就形成了类之间的实现层次关系。 例如显示器类，类的实现层次上，有各种各样的品牌显示器，类的功能实现上，显示器可以打开，关闭，调节等 //定义显示器类 class Monitor{ //持有功能层次接口的引用 MonitorFun impl
2021-02-27 11:11:57
131
原创 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
161
原创 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
192
原创 prototype模式
原型模式：根据已有对象，来创建新的对象。 client：用于注册、获取对象 prototype：原型对象接口 concreteprototype：具体的对象实现 //原型对象接口 interface Prototype{ //定义生成对象的方法 void clone() } //某一具体的原型对象 class A implements Prototype { public void clone (){ //具体是怎么根据已有对象，来生成新对象的 } } class Client { //存储
2021-02-25 21:28:24
204
原创 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
122
原创 工厂模式
工厂模式：产品由工厂生成，具体的产品由具体的工厂生成 Factory中定义生成产品的方法，Product是产品接口。 IDCardFactory是Factory的某一个具体实现，用来生成具体产品IDCard
2021-02-24 22:03:28
135
原创 模板模式
模板模式：接口中定义流程，具体的执行细节由子类实现。 比如说把大象装进冰箱里，第一步打开冰箱，第二步放入大象，第三步关上冰箱。接口中定义这样的步骤，至于具体是怎么实现的，交给子类去实现。 //定义步骤 interface Template{ void open(); void put(); void close(); } //实现步骤 class A implement Template{ public void open(){ //打开冰箱，具体怎么打开，需要自己实现 } public
2021-02-24 21:48:25
119
原创 adapter模式
适配器模式：将原有的接口进行转换，达到复用的目的 比如说我手头上有220v的充电器，但是当地只有110v的电压，无法直接使用。现在就需要一个中间的转换器，完成电压的转换(实际完成工作的，还是那个220v的充电器)。 适配器模式有两种实现：1.继承 2.委托 继承方式实现： //220v的充电器 class Charger1 { //220v充电方法 void chargeWith220V(); } //110v的充电器 interface Charger2 { //110v充电方法 void
2021-02-23 22:46:13
172
原创 iterator模式
迭代器模式，将数据的遍历与数据分离，遍历数据集合与数据集合的实现不再关联。 Aggregate：集合接口 ConcreteAggregate：具体的集合实现 Iterator：迭代器接口 ConcreteIterator：具体的迭代器实现 集合接口Aggregate内部会包含一个迭代器接口Iterator，迭代器接口中定义了hasNext、next 方法。 hasNext方法用于判断元素是否遍历完成，nex方法t用于返回当前游标指向的元素，并将游标后移。 遍历元素时，调用Iterator接口中的方法，与集
2021-02-23 22:07:29
161
原创 spring resource
resource public interface InputStreamSource { //定位并打开资源，返回一个用于读取资源的InputStream。预期每次调用都会返回一个新的InputStream。调用者负责关闭流 InputStream getInputStream() throws IOException; } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ public interfa
2021-01-27 23:43:00
120
原创 FileReader | FileWriter
FileReader FileReader按字符读取文件，本身未实现任何read方法，通过调用继承的InputStreamReader中的read方法实现读取 构造函数 public FileReader(File file) throws FileNotFoundException { //调用inputstreamreader的构造函数，进行初始化 super(new FileInputStream(file)); } FileWriter FileWriter 按字符写入
2020-12-30 10:07:32
142
原创 InputStreamReader
InputStreamReader InputStreamReader可以将字节流转为字符流， 构造函数 public InputStreamReader(InputStream in) { //设置对象锁 super(in); try { //确定解码格式，分配缓冲区 sd = StreamDecoder.forInputStreamReader(in, this, (String)null); } ca
2020-12-29 17:15:32
637
原创 BufferedInputStream | BufferedOutputStream
BufferedInputStream 是一个包装类，通过持有inputstream的引用，并在原有read方法基础上添加buffer数组缓存，实现了缓冲的目的。 构造函数，需要传入实际的inputstream，默认缓冲数组大小8192,8kb public BufferedInputStream(InputStream in) { this(in, DEFAULT_BUFFER_SIZE); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2020-12-25 14:54:43
310
1
原创 CopyOnWriteArrayList
CopyOnWriteArrayList 是一个线程安全的集合，读写分离，读不加锁，写时复制新数组，在新数组上操作。读取数据时，有可能读到旧数组中数据。 如果对象元素很多，拷贝时会很占内存 //构造函数，创建一个空数组 public CopyOnWriteArrayList() { setArray(new Object[0]); } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2020-12-24 11:24:45
164
原创 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
229
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人