diff --git a/.gitignore b/.gitignore index 535b116..eb8f1bb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ -pic -**.docx +pic +**.docx **.doc \ No newline at end of file diff --git a/README.md b/README.md index 2b566a8..9b51cff 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# technology-note -记录技术笔记 - +# technology-note +记录技术笔记 + 说明：github不支持markdown中内嵌base64图片，故需要查看图片请使用其他markdown软件查看文章 \ No newline at end of file diff --git a/spring/1.spring基础.md b/spring/1.spring基础.md index 984fc5d..fa7ffca 100644 --- a/spring/1.spring基础.md +++ b/spring/1.spring基础.md @@ -1,170 +1,170 @@ -  spring是为了解决企业级应用开发的复杂性而创建的，spring最根本的使命是：简化Java开发。为降低开发复杂性有以下四种关键策略。 - -- 基于POJO的轻量级和最小侵入性编程 -- 通过依赖注入和面向接口实现松耦合 -- 基于切面和惯例进行声明式编程 -- 通过切面和模板减少样板式代码 - -#### 1.依赖注入 - -​  假设类A依赖类B，通常做法是在类A中声明类B，然后使用，这样一方面具有极高的耦合性，将类A与类B绑定在一起；另一方面也让单元测试变得很困难，无法在A外部获得B的执行情况。 - -​  通过依赖注入，对象的依赖管理将不用对象本身来管理，将由一个第三方组件在创建对象时设定，依赖关系将被自动注入到对应的对象中去。 - -#### 2.创建应用上下文 - -- `ClassPathXmlApplicationContext()`从类路径创建 -- `FileSystemXmlApplicationContext()`读取文件系统下的xml配置 -- `XmlWebApplicationContext()` 读取web应用下的XML配置文件并装载上下文定义 - -#### 3.声明Bean - -1. 最简单 - - `` - -2. 带构造器 - - ```xml - - //基本数据类型使用value - //对象使用ref - - ``` - -3. 通过工厂方法创建 - - 如果想声明的Bean没有一个公开的构造函数，通过factory-method属性来装配工厂生产的Bean - - ```xml - //getInstance为获取实例的静态方法。 - ``` - -#### 4.Bean的作用域 - -​ 所有Spring Bean默认都是单例的。通过配置scope属性为prototype可每次请求产生一个新的实例。 - -```xml - -``` - -scope可选值： - -- `singleton`：每个容器中，一个Bean对象只有一个实例。（**默认**） -- `prototype`：允许实例化任意次 ，每次请求都会创建新的 -- `request`：作用域为一次http请求 -- `session`：作用域为一个http session会话 -- `global-session`：作用域为一个全局http session，仅在Protlet上下文中有效 - -#### 5.初始化和销毁Bean - -​ 当实例化需要执行初始化操作，或者销毁时需要执行清理工作。两种实现方式： - -1. xml配置，类中编写初始化方法和销毁方法，在bean中定义。 - - ```xml - - ``` - - 也可在Beans中定义默认初始化和销毁方法。 - - ```xml - - ``` - -2. 实现`InitializingBean `和`DisposableBean`接口 - -#### 6.setter注入 - -​ 在bean中使用``元素配置属性，使用方法类似于`` - -```xml - //注入基本数据类型 - //注入类 -``` - - 可使用p简写,**-ref**后缀说明装配的是一个引用 - -```xml - -``` - -#### 7.注入内部Bean - -​ 既定义其他Bean内部的Bean，避免共享问题，可在属性节点或者构造器参数节点上使用。 - -```xml - - //没有id属性，因为不会被其他bean使用 - - - - -``` - -#### 8.装配集合 - -| 集合元素 | 用途 | -| ---------------- | ------------------------------ | -| \ | 装配list类型，允许重复 | -| \ | set，不能重复 | -| \ | map类型 | -| \ | properties类型，键值都为String | - -- list - - ```xml - - - - - - - - 用来定义上下文中的其他引用，还可使用,, - ``` - -- set - - ```xml - - - - ``` - - 用法和list相同，只是不能重复 - -- Map - - ```XML - - - - ``` - - entry元素由一个key，一个value组成，分别有两种形式。 - - | key | 键为String | - | :-------- | -------------- | - | key-ref | 键为Bean的引用 | - | value | 值为String | - | value-ref | 值为Bean的引用 | - -- props - - ```xml - - guitar - - ``` - - 键值都是String - -#### 9.装配空值 - -```xml - -``` - +  spring是为了解决企业级应用开发的复杂性而创建的，spring最根本的使命是：简化Java开发。为降低开发复杂性有以下四种关键策略。 + +- 基于POJO的轻量级和最小侵入性编程 +- 通过依赖注入和面向接口实现松耦合 +- 基于切面和惯例进行声明式编程 +- 通过切面和模板减少样板式代码 + +#### 1.依赖注入 + +​  假设类A依赖类B，通常做法是在类A中声明类B，然后使用，这样一方面具有极高的耦合性，将类A与类B绑定在一起；另一方面也让单元测试变得很困难，无法在A外部获得B的执行情况。 + +​  通过依赖注入，对象的依赖管理将不用对象本身来管理，将由一个第三方组件在创建对象时设定，依赖关系将被自动注入到对应的对象中去。 + +#### 2.创建应用上下文 + +- `ClassPathXmlApplicationContext()`从类路径创建 +- `FileSystemXmlApplicationContext()`读取文件系统下的xml配置 +- `XmlWebApplicationContext()` 读取web应用下的XML配置文件并装载上下文定义 + +#### 3.声明Bean + +1. 最简单 + + `` + +2. 带构造器 + + ```xml + + //基本数据类型使用value + //对象使用ref + + ``` + +3. 通过工厂方法创建 + + 如果想声明的Bean没有一个公开的构造函数，通过factory-method属性来装配工厂生产的Bean + + ```xml + //getInstance为获取实例的静态方法。 + ``` + +#### 4.Bean的作用域 + +​ 所有Spring Bean默认都是单例的。通过配置scope属性为prototype可每次请求产生一个新的实例。 + +```xml + +``` + +scope可选值： + +- `singleton`：每个容器中，一个Bean对象只有一个实例。（**默认**） +- `prototype`：允许实例化任意次 ，每次请求都会创建新的 +- `request`：作用域为一次http请求 +- `session`：作用域为一个http session会话 +- `global-session`：作用域为一个全局http session，仅在Protlet上下文中有效 + +#### 5.初始化和销毁Bean + +​ 当实例化需要执行初始化操作，或者销毁时需要执行清理工作。两种实现方式： + +1. xml配置，类中编写初始化方法和销毁方法，在bean中定义。 + + ```xml + + ``` + + 也可在Beans中定义默认初始化和销毁方法。 + + ```xml + + ``` + +2. 实现`InitializingBean `和`DisposableBean`接口 + +#### 6.setter注入 + +​ 在bean中使用``元素配置属性，使用方法类似于`` + +```xml + //注入基本数据类型 + //注入类 +``` + + 可使用p简写,**-ref**后缀说明装配的是一个引用 + +```xml + +``` + +#### 7.注入内部Bean + +​ 既定义其他Bean内部的Bean，避免共享问题，可在属性节点或者构造器参数节点上使用。 + +```xml + + //没有id属性，因为不会被其他bean使用 + + + + +``` + +#### 8.装配集合 + +| 集合元素 | 用途 | +| ---------------- | ------------------------------ | +| \ | 装配list类型，允许重复 | +| \ | set，不能重复 | +| \ | map类型 | +| \ | properties类型，键值都为String | + +- list + + ```xml + + + + + + + + 用来定义上下文中的其他引用，还可使用,, + ``` + +- set + + ```xml + + + + ``` + + 用法和list相同，只是不能重复 + +- Map + + ```XML + + + + ``` + + entry元素由一个key，一个value组成，分别有两种形式。 + + | key | 键为String | + | :-------- | -------------- | + | key-ref | 键为Bean的引用 | + | value | 值为String | + | value-ref | 值为Bean的引用 | + +- props + + ```xml + + guitar + + ``` + + 键值都是String + +#### 9.装配空值 + +```xml + +``` + diff --git a/spring/2.最小化XML配置.md b/spring/2.最小化XML配置.md index c530b89..aade21a 100644 --- a/spring/2.最小化XML配置.md +++ b/spring/2.最小化XML配置.md @@ -1,223 +1,223 @@ -## 一、自动装配 - -### 1、四种类型的自动装配 - -| 类型 | 解释 | xml配置 | -| ---------- | ------------------------------------ | ---------------------------------------------- | -| byName | 根据Bean的name或者id | \ | -| ByType | 根据Bean类型自动装配 | \ | -| contructor | 根据Bean的构造器入参具有相同类型 | 同上 | -| Autodetect | 首先使用contructor，失败再尝试byType | 同上 | - -  byType在出现多个匹配项时不会自动选择一个然是报错，为避免报错，有两种办法：1.使用\元素的primary属性，设置为首选Bean，但所有bean的默认primary都是true，因此我们需要将所有非首选Bean设置为false；2.将Bean的`autowire-candidate`熟悉设置为**false **，取消 这个Bean的候选资格，这个Bean便不会自动注入了。 - -  contructor自动装配和byType有一样的局限性，当发现多个Bean匹配某个构造器入参时，Spring不会尝试选择其中一个；此外，如果一个类有多个构造器都满足自动装配的条件，Spring也不会猜测哪个更合适使用。 - -###2、默认自动装配 - -  如果需要为Spring应用上下文中的每个Bean（或者其中的大多数）配置相同的autowire属性，可以在根元素\上增加一个default-autowire属性，默认该属性设置为none。该属性只应用于指定配置文件中的所有Bean，并不是Spring上下文中的所有Bean。 - -###3、混合使用自动装配和显式装配 - -   当我们对某个Bean使用了自动装配策略，并不代表我们不能对该Bean的某些属性进行显示装配，任然可以为任意一个属性配置\元素，显式装配将会覆盖自动装配。**但是**当使用constructor自动装配策略时，我们必须让Spring自动装配构造器所有入参，不能使用\元素进行混合。 - -## 二、注解装配 - -  从Spring2.5开始，可以使用注解自动装配Bean的属性，使用注解允许更细粒度的自动装配，可选择性的标注某一个属性来对其应用自动装配。Spring容器默认禁用注解装配，需要在Spring配置中启用，最简单的启用方式是使用Spring的context命令空间配置中的``,如下所示： - -```xml - - - - -``` - -  Spring3支持几种不同的用于自动装配的注解： - -- Spring自带的@Autowired注解 -- JSR-330的@Inject注解 -- JSR-250的@Resource注解 - -###1、使用@Autowired - -  @Autowired用于对被注解对象启动ByType的自动装配，可用于以下对象: - -- 类属性，即使私有属性也能注入 -- set方法 -- 构造器 -- 任意需要装配Bean的方法 - -在使用@Autowired时有两种情况会出错：没有匹配的Bean和存在多个匹配的Bean，但是都有对应的解决方法。 - -- 当没有匹配Bean时，自动装配会抛出NoSuchBeanDefinitionException，如果不想抛出可使用required属性，设置为false来配置可选的自动装配，即装配失败就不进行装配，不会报错。 - - ```java - @Autowired(required=false) - ``` - - 当使用构造器配置时，只有一个构造器可以将required属性设置为true，其他都只能设置为false。此外，当使用注解标注多个构造器时，Spring会从所有满足装配条件的构造器中选择入参最多的那个。 - -- 当存在多个Bean满足装配条件时，Spring也会抛出NoSuchBeanDefinitionException错误，为了选择指定的Bean，我们可以使用@Qualifier注解进行筛选: - - ```java - @Autowired - @Qualifier("name1")//筛选名为name1的Bean - private TestClass testClass; - ``` - - 除了通过Bean的ID来缩小选择范围，我们还可以通过直接在Bean上使用qualifier来缩小范围，限制Bean的类型，xml如下： - - ```xml - - - - ``` - - 注解如下： - - ```java - @Qualifier("stringed") - public class xxx{} - ``` - - 还可以创建**自定义限定器（Qualifier）** - -   创建自定义限定器只需要使用@Qualifier注解作为它的源注解即可，如下创建了一个Stringed限定器： - - ```java - @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.TYPE}) - @Retention(RetentionPolicy.RUNTIME) - @Qualifier - public @interface Stringed{} - ``` - - 然后使用它注解一个Bean: - - ```java - @Stringed - public class Guitar{} - ``` - - 然后就可以进行限定了： - - ```java - @Autowired - @Stringed - private Guitar guitar; - ``` - -### 2、使用@Inject自动注入 - -  为统一各种依赖注入框架的编程模型，JCP（Java Community Process）发布的Java依赖注入规范，被称为JSR-330，从Spring3开始，Spring已经开始兼容该依赖注入模型。 - -  和@Autowired一样，@Inject可以用来自动装配属性、方法和构造器。但是@Inject没有required属性，因此依赖关系必须存在，如不存在将抛出异常。 - -  JSR-330还提供另一种注入技巧，注入一个Provider。Provider接口可以实现Bean引用的延迟注入以及注入Bean的多个实例等功能。 - -  例如我们有一个KnifeJuggler类需要注入一个或多个Knife实例，假设Knife Bean的作用域声明为prototype，下面的KnifeJuggler的构造器将获得多个Knife Bean: - -```java -private Set knifes; - -@Inject -public KnifeJuggler(Provider knifeProvider){ - knives = new HashSet(); - for(int i=0;i<5;i++){ - knives.add(knifeProvider.get()); - } -} -``` - -  相对于@Autowired所对应的@Qualifier，@Inject对应的是@Named注解。事实上JSR-330中也有@Qualifier注解，不过不建议直接使用，建议通过该注解来创建自定义的限定注解，和Spring的@Qualifier创建过程类似。 - -### 3、注解中使用表达式 - -  Spring3中引入的`@Value`属性可用来装配String类型的值和基本类型的值。借助SpEL表达式，@Value不光可以装配硬编码值还可以在运行期动态计算表达式并装配，例如下面的： - -```java -@Value("#{systemProperties.name}") -private String name; -``` - -## 三、自动检测Bean - -  在Spring中使用上面说到的``，可以做到自动装配，但还是要在xml中申明Bean。Spring还有另一个元素``,元素除了完成自动装配的功能，还允许Spring自动检测Bean和定义Bean ，用法如下： - -```xml - - - - -``` - -开启后支持如下注解： - -| 注解 | 解释 | -| ----------- | ------------------------------------ | -| @Component | 通用的构造型注解，标识类为Spring组件 | -| @Controller | 标识该类定义为Spring MVC controller | -| @Repository | 标识该类定义为数据仓库 | -| @Service | 标识该类定义为服务 | - -  使用上述注解是Bean的ID默认为无限定类名。使用`@Component("name")`指定ID。 - -### 1、过滤组建扫描 - -  通过为配置和子元素，我们可以随意调整扫描行为。下面的配置自动注册所有的TestInterface实现类： - -```xml - - - -``` - -其中的type和expression属性一起协作来定义组件扫描策略。type有以下值可选择： - -| 过滤器类型 | 描述 | -| ---------- | ------------------------------------------------------------ | -| annotation | 过滤器扫描使用指定注解所标注的类。通过expression属性指定要扫描的注解 | -| assignable | 过滤器扫描派生于expression属性所指定类型的那些类 | -| aspectj | 过滤器扫描于expression属性所指定的AspectJ表达式所匹配的那些类 | -| custom | 使用自定义的org.springframework.core.type.TypeFilter实现类，该类由expression属性指定 | -| regex | 过滤器扫描类的名称与expression属性所指定的正则表达式所匹配的类 | - -  exclude-filter使用和include-filter类似，只是效果相反。 - -## 四、使用Spring基于Java的配置 - -  在Spring3.0中几乎可以不使用XML而使用纯粹的Java代码来配置Spring应用。 - -- 首先还是需要极少量的XML来启用Java配置，就是上面说到的``,该标签还会自动加载使用`@Configuration`注解所标识的类 - -- @Configuration注解相当于XML配置中的\元素，这个注解将会告知Spring：这个类包含一个或多个Spring Bean的定义，这些定义是使用@Bean注解所标注的方法 - -- 申明一个简单的Bean代码如下： - - ```java - @Configuration - public class TestConfig{ - @Bean - public Animal duck(){ - return new Ducker(); - } - } - ``` - - @Bean告知Spring这个方法将返回一个对象，该对象应该被注册为Spring应用上下文中的一个Bean，方法名作为该Bean的ID 。想要使用另一个Bean的引用也很简单，如下： - - ```java - @Bean - public Food duckFood(){ - return new DuckFood(); - } - - @Bean //通过方法名引用一个Bean，并不会创建一个新的实例 - public Animal duck(){ - return new Ducker(DuckFood()); - } - ``` - - ## 五、小结 - +## 一、自动装配 + +### 1、四种类型的自动装配 + +| 类型 | 解释 | xml配置 | +| ---------- | ------------------------------------ | ---------------------------------------------- | +| byName | 根据Bean的name或者id | \ | +| ByType | 根据Bean类型自动装配 | \ | +| contructor | 根据Bean的构造器入参具有相同类型 | 同上 | +| Autodetect | 首先使用contructor，失败再尝试byType | 同上 | + +  byType在出现多个匹配项时不会自动选择一个然是报错，为避免报错，有两种办法：1.使用\元素的primary属性，设置为首选Bean，但所有bean的默认primary都是true，因此我们需要将所有非首选Bean设置为false；2.将Bean的`autowire-candidate`熟悉设置为**false **，取消 这个Bean的候选资格，这个Bean便不会自动注入了。 + +  contructor自动装配和byType有一样的局限性，当发现多个Bean匹配某个构造器入参时，Spring不会尝试选择其中一个；此外，如果一个类有多个构造器都满足自动装配的条件，Spring也不会猜测哪个更合适使用。 + +###2、默认自动装配 + +  如果需要为Spring应用上下文中的每个Bean（或者其中的大多数）配置相同的autowire属性，可以在根元素\上增加一个default-autowire属性，默认该属性设置为none。该属性只应用于指定配置文件中的所有Bean，并不是Spring上下文中的所有Bean。 + +###3、混合使用自动装配和显式装配 + +   当我们对某个Bean使用了自动装配策略，并不代表我们不能对该Bean的某些属性进行显示装配，任然可以为任意一个属性配置\元素，显式装配将会覆盖自动装配。**但是**当使用constructor自动装配策略时，我们必须让Spring自动装配构造器所有入参，不能使用\元素进行混合。 + +## 二、注解装配 + +  从Spring2.5开始，可以使用注解自动装配Bean的属性，使用注解允许更细粒度的自动装配，可选择性的标注某一个属性来对其应用自动装配。Spring容器默认禁用注解装配，需要在Spring配置中启用，最简单的启用方式是使用Spring的context命令空间配置中的``,如下所示： + +```xml + + + + +``` + +  Spring3支持几种不同的用于自动装配的注解： + +- Spring自带的@Autowired注解 +- JSR-330的@Inject注解 +- JSR-250的@Resource注解 + +###1、使用@Autowired + +  @Autowired用于对被注解对象启动ByType的自动装配，可用于以下对象: + +- 类属性，即使私有属性也能注入 +- set方法 +- 构造器 +- 任意需要装配Bean的方法 + +在使用@Autowired时有两种情况会出错：没有匹配的Bean和存在多个匹配的Bean，但是都有对应的解决方法。 + +- 当没有匹配Bean时，自动装配会抛出NoSuchBeanDefinitionException，如果不想抛出可使用required属性，设置为false来配置可选的自动装配，即装配失败就不进行装配，不会报错。 + + ```java + @Autowired(required=false) + ``` + + 当使用构造器配置时，只有一个构造器可以将required属性设置为true，其他都只能设置为false。此外，当使用注解标注多个构造器时，Spring会从所有满足装配条件的构造器中选择入参最多的那个。 + +- 当存在多个Bean满足装配条件时，Spring也会抛出NoSuchBeanDefinitionException错误，为了选择指定的Bean，我们可以使用@Qualifier注解进行筛选: + + ```java + @Autowired + @Qualifier("name1")//筛选名为name1的Bean + private TestClass testClass; + ``` + + 除了通过Bean的ID来缩小选择范围，我们还可以通过直接在Bean上使用qualifier来缩小范围，限制Bean的类型，xml如下： + + ```xml + + + + ``` + + 注解如下： + + ```java + @Qualifier("stringed") + public class xxx{} + ``` + + 还可以创建**自定义限定器（Qualifier）** + +   创建自定义限定器只需要使用@Qualifier注解作为它的源注解即可，如下创建了一个Stringed限定器： + + ```java + @Target({ElementType.FIELD,ElementType.PARAMETER,ElementType.TYPE}) + @Retention(RetentionPolicy.RUNTIME) + @Qualifier + public @interface Stringed{} + ``` + + 然后使用它注解一个Bean: + + ```java + @Stringed + public class Guitar{} + ``` + + 然后就可以进行限定了： + + ```java + @Autowired + @Stringed + private Guitar guitar; + ``` + +### 2、使用@Inject自动注入 + +  为统一各种依赖注入框架的编程模型，JCP（Java Community Process）发布的Java依赖注入规范，被称为JSR-330，从Spring3开始，Spring已经开始兼容该依赖注入模型。 + +  和@Autowired一样，@Inject可以用来自动装配属性、方法和构造器。但是@Inject没有required属性，因此依赖关系必须存在，如不存在将抛出异常。 + +  JSR-330还提供另一种注入技巧，注入一个Provider。Provider接口可以实现Bean引用的延迟注入以及注入Bean的多个实例等功能。 + +  例如我们有一个KnifeJuggler类需要注入一个或多个Knife实例，假设Knife Bean的作用域声明为prototype，下面的KnifeJuggler的构造器将获得多个Knife Bean: + +```java +private Set knifes; + +@Inject +public KnifeJuggler(Provider knifeProvider){ + knives = new HashSet(); + for(int i=0;i<5;i++){ + knives.add(knifeProvider.get()); + } +} +``` + +  相对于@Autowired所对应的@Qualifier，@Inject对应的是@Named注解。事实上JSR-330中也有@Qualifier注解，不过不建议直接使用，建议通过该注解来创建自定义的限定注解，和Spring的@Qualifier创建过程类似。 + +### 3、注解中使用表达式 + +  Spring3中引入的`@Value`属性可用来装配String类型的值和基本类型的值。借助SpEL表达式，@Value不光可以装配硬编码值还可以在运行期动态计算表达式并装配，例如下面的： + +```java +@Value("#{systemProperties.name}") +private String name; +``` + +## 三、自动检测Bean + +  在Spring中使用上面说到的``，可以做到自动装配，但还是要在xml中申明Bean。Spring还有另一个元素``,元素除了完成自动装配的功能，还允许Spring自动检测Bean和定义Bean ，用法如下： + +```xml + + + + +``` + +开启后支持如下注解： + +| 注解 | 解释 | +| ----------- | ------------------------------------ | +| @Component | 通用的构造型注解，标识类为Spring组件 | +| @Controller | 标识该类定义为Spring MVC controller | +| @Repository | 标识该类定义为数据仓库 | +| @Service | 标识该类定义为服务 | + +  使用上述注解是Bean的ID默认为无限定类名。使用`@Component("name")`指定ID。 + +### 1、过滤组建扫描 + +  通过为配置和子元素，我们可以随意调整扫描行为。下面的配置自动注册所有的TestInterface实现类： + +```xml + + + +``` + +其中的type和expression属性一起协作来定义组件扫描策略。type有以下值可选择： + +| 过滤器类型 | 描述 | +| ---------- | ------------------------------------------------------------ | +| annotation | 过滤器扫描使用指定注解所标注的类。通过expression属性指定要扫描的注解 | +| assignable | 过滤器扫描派生于expression属性所指定类型的那些类 | +| aspectj | 过滤器扫描于expression属性所指定的AspectJ表达式所匹配的那些类 | +| custom | 使用自定义的org.springframework.core.type.TypeFilter实现类，该类由expression属性指定 | +| regex | 过滤器扫描类的名称与expression属性所指定的正则表达式所匹配的类 | + +  exclude-filter使用和include-filter类似，只是效果相反。 + +## 四、使用Spring基于Java的配置 + +  在Spring3.0中几乎可以不使用XML而使用纯粹的Java代码来配置Spring应用。 + +- 首先还是需要极少量的XML来启用Java配置，就是上面说到的``,该标签还会自动加载使用`@Configuration`注解所标识的类 + +- @Configuration注解相当于XML配置中的\元素，这个注解将会告知Spring：这个类包含一个或多个Spring Bean的定义，这些定义是使用@Bean注解所标注的方法 + +- 申明一个简单的Bean代码如下： + + ```java + @Configuration + public class TestConfig{ + @Bean + public Animal duck(){ + return new Ducker(); + } + } + ``` + + @Bean告知Spring这个方法将返回一个对象，该对象应该被注册为Spring应用上下文中的一个Bean，方法名作为该Bean的ID 。想要使用另一个Bean的引用也很简单，如下： + + ```java + @Bean + public Food duckFood(){ + return new DuckFood(); + } + + @Bean //通过方法名引用一个Bean，并不会创建一个新的实例 + public Animal duck(){ + return new Ducker(DuckFood()); + } + ``` + + ## 五、小结 +   终于写完了spring 的最小化配置，对spring的各种注解也有了一些了解，再不是之前看到注解一脸莫名其妙了，虽然现在Springboot已经帮我们做了零XML配置，但觉得还是有必要了解下XML配置实现，这样对Java的配置实现理解也会更加深刻。 \ No newline at end of file diff --git a/spring/3.面向切面的Spring.md b/spring/3.面向切面的Spring.md index 999d31a..d49fef9 100644 --- a/spring/3.面向切面的Spring.md +++ b/spring/3.面向切面的Spring.md @@ -1,239 +1,239 @@ - ## 一.面向切面编程 - -  Spring的基础是IOC和AOP，前面两节对IOC和DI做了简单总结，这里再对AOP进行一个学习总结，Spring基础就算有一个初步了解了。 - -  在软件开发中，我们可能需要一些跟业务无关但是又必须做的东西，比如日志，事务等，这些分布于应用中多处的功能被称为横切关注点，通常横切关注点从概念上是与应用的业务逻辑相分离的。如何将这些横切关注点与业务逻辑在代码层面进行分离，是面向切面编程（**AOP**）所要解决的。 - -​ 横切关注点可以被描述为影响应用多处的功能，切面能够帮助我们模块化横切关注点。下图直观呈现了横切关注点的概念: - -![横切关注点](./3.面向切面的Spring/切面示例.png) - -途中CourseService，StudentService，MiscService都需要类似安全、事务这样的辅助功能，这些辅助功能就被称为横切关注点。 - -  **继承**和**委托**是最常见的实现重用通用功能的面向对象技术。但是如果在整个程序中使用相同的基类继承往往会导致一个脆弱的对象体系；而使用委托可能需要对委托对象进行复杂的调用。 - -​ 切面提供了取代继承和委托的另一种选择，而且更加清晰简洁。在面向切面编程时，我们任然在一个地方定义通用功能，但是我们可以通过声明的方式定义这个功能以何种方式在何处应用，而无需修改受影响的类，受影响类完全感受不到切面的存在。 - -## 二.AOP常用术语 - -  下面是AOP中常用的名词。 - -### 1. 通知（Advice） - -  通知定义了切面是什么以及何时使用。出了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。Sping切面可以应用以下5种类型的通知。 - -- **Before** 在方法被调用之前调用通知 -- **After** 在方法完成之后调用通知，无论方法执行是否成功 -- **After-returning** 在方法成功执行后调用通知 -- **After-throwing** 在方法抛出异常后调用通知 -- **Around** 通知包裹了被通知的方法，在被通知的方法调用前和调用后执行 - -###2.连接点（Joinpoint） - -  应用可能有很多个时机应用通知，这些时机被称为连接点。连接点是应用在执行过程中能够插入切面的一个点，这个点可以是调用方法时、抛出异常时、甚至是修改字段时。切面代码可以利用这些切入到应用的正常流程中，并添加新的行为。 - -### 3.切点（Pointcut） - -  切点定义了通知所要织入的一个或多个连接点。如果说通知定义了切面的“**什么**”和“**何时**”，那么切点就定义了“**何处**”。通常使用明确的类和方法名称来指定切点，或者利用正则表达式定义匹配的类和方法来指定这些切点。有些AOP框架允许我们创建动态的切点，可以更具运行时的策略来决定是否应用通知。 - -### 4.切面（Aspect） - -  切面是通知和切点的结合。通知和切点定义了关于切面的全部内容，**是什么**，在**何时**、**何处**完成其功能。 - -### 5.引入 - -  引入允许我们想现有的类添加新方法或属性。即在无需修改现有类的情况下让它们具有新的行为和状态。 - -### 6.织入 - -  织入是将切面应用到目标对象来创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中，在目标对象的生命周期里有多个点可以进行织入。 - -- 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译期，比如AspectJ的织入编译期 -- 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的加载器，它可以在目标类被引入应用之前增强该目标类的字节码，例如AspectJ5的**LTW**（load-time weaving） -- 运行期：切面在应用运行的某个时刻被织入。一般情况下AOP容器会为目标对象动态创建一个代理对象 - -##三.Spring AOP - -  Spring在运行期通知对象，通过在代理类中包裹切面，Spring在运行期将切面织入到Spring管理的Bean中。代理类封装了目标类，并拦截被通知的方法的调用，再将调用转发给真正的目标Bean。由于Spring是基于动态代理，所有Spring只支持方法连接点，如果需要方法拦截之外的连接点拦截，我们可以利用Aspect来协助SpringAOP。 - -  Spring在运行期通知对象，通过在代理类中包裹切面，Spring在运行期将切面织入到Spring管理的Bean中。代理类封装了目标类，并拦截被通知的方法的调用，再将调用转发给真正的目标Bean。由于Spring是基于动态代理，所有Spring只支持方法连接点，如果需要方法拦截之外的连接点拦截，我们可以利用Aspect来协助SpringAOP。 - -### 1、定义切点 - -  在SpringAOP中，需要使用AspectJ的切点表达式语言来定义切点。Spring只支持AspectJ的部分切点指示器，如下表所示： - -| AspectJ指示器 | 描述 | -| ------------- | ------------------------------------------------------------ | -| arg() | 限制连接点匹配参数为指定类型的执行方法 | -| @args() | 限制连接点匹配参数由指定注解标注的执行方法 | -| execution() | 用于匹配是连接点的执行方法 | -| this() | 限制连接点匹配AOP代理的Bean引用为指导类型的类 | -| target() | 限制连接点匹配目标对象为指定类型的类 | -| @target() | 限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型的注解 | -| within() | 限制连接点匹配指定的类型 | -| @within() | 限制连接点匹配指定注解所标注的类型（当使用SpringAOP时，方法定义在由指定的注解所标注的类里） | -| @annotation | 限制匹配带有指定注解连接点 | -| bean() | 使用Bean ID或Bean名称作为参数来限制切点只匹配特定的Bean | - - 其中只有execution指示器是唯一的执行匹配，其他都是限制匹配。因此execution指示器是 - -其中只有execution指示器是唯一的执行匹配，其他都是限制匹配。因此execution指示器是我们在编写切点定义时最主要使用的指示器。 - -### 2、编写切点 - -  假设我们要使用execution()指示器选择Hello类的sayHello()方法，表达式如下： - -```java -execution(* com.test.Hello.sayHello(..)) -``` - -方法表达式以*** **号开始，说明不管方法返回值的类型。然后指定全限定类名和方法名。对于方法参数列表，我们使用（**）标识切点选择任意的sayHello()方法，无论方法入参是什么。 - -  同时我们可以使用&&(and)，||(or)，！(not)来连接指示器,如下所示： - -```java -execution(* com.test.Hello.sayHello(..)) and !bean(xiaobu) -``` - -### 3、申明切面 - -  在经典Spring AOP中使用ProxyFactoryBean非常复杂，因此提供了申明式切面的选择，在Spring的AOP配置命名空间中有如下配置元素： - -| AOP配置元素 | 描述 | -| ------------------------------ | ----------------------------------------------------------- | -| <aop:advisor > | 定义AOP通知器 | -| <aop:after > | 定义AOP后置通知（无论被通知方法是否执行成功） | -| <aop:after-returning > | 定义AOP after-returning通知 | -| <aop:after-throwing > | 定义after-throwing | -| <aop:around > | 定义AOP环绕通知 | -| <aop:aspect > | 定义切面 | -| <aop:aspectj-autoproxy > | 启用@AspectJ注解驱动的切面 | -| <aop:before > | 定义AOP前置通知 | -| <aop:config > | 顶层的AOP配置元素。大多数的<aop:* >元素必须包含在其中 | -| <aop:declare-parents > | 为被通知的对象引入额外的接口，并透明的实现 | -| <aop:pointcut > | 定义切点 | - -### 4、实现 - -假设有一个演员类`Actor`，演员类中有一个表演方法`perform()`,然后还有一个观众类`Audience`,这两个类都在包`com.example.springtest`下，Audience类主要方法如下： - -```java -public class Audience{ - //搬凳子 - public void takeSeats(){} - //欢呼 - public void applaud(){} - //计时，环绕通知需要一个ProceedingJoinPoint参数 - public void timing(ProceedingJoinPoint joinPoint){ - joinPoint.proceed(); - } - //演砸了 - public void demandRefund(){} - //测试带参数 - public void dealString(String word){} - -} -``` - -#### a、xml配置实现 - -  首先将Audience配置到springIOC中: - -```xml - -``` - -然后申明通知： - -```xml - - - - - - - - - - - - - - - - - - -``` - - - -#### b、注解实现 - -直接在Audience类上加注解（Aspect注解并不能被spring自动发现并注册，要么写到xml中，要么使用@Aspectj注解或者加一个@Component注解），如下所示： - -```java -@Aspect -public class Audience{ - //定义切点 - @Pointcut(execution(* com.example.springtest.Performer.perform(..))) - public void perform(){} - - //定义带参数切点 - @Pointcut(execution(* com.example.springtest.Performer.performArg(String) and args(word))) - public void performStr(String word){} - - //搬凳子 - @Before("perform()") - public void takeSeats(){} - - //欢呼 - @AfterReturning("perform()") - public void applaud(){} - - //计时，环绕通知需要一个ProceedingJoinPoint参数 - @Around("perform()") - public void timing(ProceedingJoinPoint joinPoint){ - joinPoint.proceed(); - } - - //演砸了 - @AfterThrowing("perform()") - public void demandRefund(){} - - //带参数 - @Before("performStr(word)") - public void dealString(String word){} -} -``` - -#### c、通过切面引入新功能 - -  既然可以用AOP为对象拥有的方法添加新功能，那为什么不能为对象增加新的方法呢？利用被称为**引入**的AOP概念，切面可以为Spring Bean添加新的方法，示例图如下： - -![引入](.\3.面向切面的Spring\引入新功能.png) - -当引入接口的方法被调用时，代理将此调用委托给实现了新接口的某个其他对象。实际上，Bean的实现被拆分到了多个类。 - -- xml引入需要使用<aop:declare-parents >元素： - - ```xml - - - - ``` - - 顾名思义\<declare-parents>声明了此切面所通知的Bean在它的对象层次结构中有了新的父类型。其中types-matching指定增强的类；implement-interface指定实现新方法的接口；default-imple指定实现了implement-interface接口的实现类，也可以用delegate-ref来指定一个Bean的引用。 - -- 注解引入，通过`@DeclareParents`注解 - - ```xml - @DeclareParents(value="com.fxb.springtest.Performer+", - defaultImpl=AddTestImpl.class) - public static AddTestInterface addTestInterface; - ``` - - 同xml实现一样，注解也由三部分组成：1、value属性相当于tpes-matching属性，标识被增强的类；2、defaultImpl等同于default-imple，指定接口的实现类；3、有@DeclareParents注解所标注的static属性指定了将被引入的接口。 - + ## 一.面向切面编程 + +  Spring的基础是IOC和AOP，前面两节对IOC和DI做了简单总结，这里再对AOP进行一个学习总结，Spring基础就算有一个初步了解了。 + +  在软件开发中，我们可能需要一些跟业务无关但是又必须做的东西，比如日志，事务等，这些分布于应用中多处的功能被称为横切关注点，通常横切关注点从概念上是与应用的业务逻辑相分离的。如何将这些横切关注点与业务逻辑在代码层面进行分离，是面向切面编程（**AOP**）所要解决的。 + +​ 横切关注点可以被描述为影响应用多处的功能，切面能够帮助我们模块化横切关注点。下图直观呈现了横切关注点的概念: + +![横切关注点](./picFolder/切面示例.png) + +途中CourseService，StudentService，MiscService都需要类似安全、事务这样的辅助功能，这些辅助功能就被称为横切关注点。 + +  **继承**和**委托**是最常见的实现重用通用功能的面向对象技术。但是如果在整个程序中使用相同的基类继承往往会导致一个脆弱的对象体系；而使用委托可能需要对委托对象进行复杂的调用。 + +​ 切面提供了取代继承和委托的另一种选择，而且更加清晰简洁。在面向切面编程时，我们任然在一个地方定义通用功能，但是我们可以通过声明的方式定义这个功能以何种方式在何处应用，而无需修改受影响的类，受影响类完全感受不到切面的存在。 + +## 二.AOP常用术语 + +  下面是AOP中常用的名词。 + +### 1. 通知（Advice） + +  通知定义了切面是什么以及何时使用。出了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。Sping切面可以应用以下5种类型的通知。 + +- **Before** 在方法被调用之前调用通知 +- **After** 在方法完成之后调用通知，无论方法执行是否成功 +- **After-returning** 在方法成功执行后调用通知 +- **After-throwing** 在方法抛出异常后调用通知 +- **Around** 通知包裹了被通知的方法，在被通知的方法调用前和调用后执行 + +###2.连接点（Joinpoint） + +  应用可能有很多个时机应用通知，这些时机被称为连接点。连接点是应用在执行过程中能够插入切面的一个点，这个点可以是调用方法时、抛出异常时、甚至是修改字段时。切面代码可以利用这些切入到应用的正常流程中，并添加新的行为。 + +### 3.切点（Pointcut） + +  切点定义了通知所要织入的一个或多个连接点。如果说通知定义了切面的“**什么**”和“**何时**”，那么切点就定义了“**何处**”。通常使用明确的类和方法名称来指定切点，或者利用正则表达式定义匹配的类和方法来指定这些切点。有些AOP框架允许我们创建动态的切点，可以更具运行时的策略来决定是否应用通知。 + +### 4.切面（Aspect） + +  切面是通知和切点的结合。通知和切点定义了关于切面的全部内容，**是什么**，在**何时**、**何处**完成其功能。 + +### 5.引入 + +  引入允许我们想现有的类添加新方法或属性。即在无需修改现有类的情况下让它们具有新的行为和状态。 + +### 6.织入 + +  织入是将切面应用到目标对象来创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中，在目标对象的生命周期里有多个点可以进行织入。 + +- 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译期，比如AspectJ的织入编译期 +- 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的加载器，它可以在目标类被引入应用之前增强该目标类的字节码，例如AspectJ5的**LTW**（load-time weaving） +- 运行期：切面在应用运行的某个时刻被织入。一般情况下AOP容器会为目标对象动态创建一个代理对象 + +##三.Spring AOP + +  Spring在运行期通知对象，通过在代理类中包裹切面，Spring在运行期将切面织入到Spring管理的Bean中。代理类封装了目标类，并拦截被通知的方法的调用，再将调用转发给真正的目标Bean。由于Spring是基于动态代理，所有Spring只支持方法连接点，如果需要方法拦截之外的连接点拦截，我们可以利用Aspect来协助SpringAOP。 + +  Spring在运行期通知对象，通过在代理类中包裹切面，Spring在运行期将切面织入到Spring管理的Bean中。代理类封装了目标类，并拦截被通知的方法的调用，再将调用转发给真正的目标Bean。由于Spring是基于动态代理，所有Spring只支持方法连接点，如果需要方法拦截之外的连接点拦截，我们可以利用Aspect来协助SpringAOP。 + +### 1、定义切点 + +  在SpringAOP中，需要使用AspectJ的切点表达式语言来定义切点。Spring只支持AspectJ的部分切点指示器，如下表所示： + +| AspectJ指示器 | 描述 | +| ------------- | ------------------------------------------------------------ | +| arg() | 限制连接点匹配参数为指定类型的执行方法 | +| @args() | 限制连接点匹配参数由指定注解标注的执行方法 | +| execution() | 用于匹配是连接点的执行方法 | +| this() | 限制连接点匹配AOP代理的Bean引用为指导类型的类 | +| target() | 限制连接点匹配目标对象为指定类型的类 | +| @target() | 限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型的注解 | +| within() | 限制连接点匹配指定的类型 | +| @within() | 限制连接点匹配指定注解所标注的类型（当使用SpringAOP时，方法定义在由指定的注解所标注的类里） | +| @annotation | 限制匹配带有指定注解连接点 | +| bean() | 使用Bean ID或Bean名称作为参数来限制切点只匹配特定的Bean | + + 其中只有execution指示器是唯一的执行匹配，其他都是限制匹配。因此execution指示器是 + +其中只有execution指示器是唯一的执行匹配，其他都是限制匹配。因此execution指示器是我们在编写切点定义时最主要使用的指示器。 + +### 2、编写切点 + +  假设我们要使用execution()指示器选择Hello类的sayHello()方法，表达式如下： + +```java +execution(* com.test.Hello.sayHello(..)) +``` + +方法表达式以*** **号开始，说明不管方法返回值的类型。然后指定全限定类名和方法名。对于方法参数列表，我们使用（**）标识切点选择任意的sayHello()方法，无论方法入参是什么。 + +  同时我们可以使用&&(and)，||(or)，！(not)来连接指示器,如下所示： + +```java +execution(* com.test.Hello.sayHello(..)) and !bean(xiaobu) +``` + +### 3、申明切面 + +  在经典Spring AOP中使用ProxyFactoryBean非常复杂，因此提供了申明式切面的选择，在Spring的AOP配置命名空间中有如下配置元素： + +| AOP配置元素 | 描述 | +| ------------------------------ | ----------------------------------------------------------- | +| <aop:advisor > | 定义AOP通知器 | +| <aop:after > | 定义AOP后置通知（无论被通知方法是否执行成功） | +| <aop:after-returning > | 定义AOP after-returning通知 | +| <aop:after-throwing > | 定义after-throwing | +| <aop:around > | 定义AOP环绕通知 | +| <aop:aspect > | 定义切面 | +| <aop:aspectj-autoproxy > | 启用@AspectJ注解驱动的切面 | +| <aop:before > | 定义AOP前置通知 | +| <aop:config > | 顶层的AOP配置元素。大多数的<aop:* >元素必须包含在其中 | +| <aop:declare-parents > | 为被通知的对象引入额外的接口，并透明的实现 | +| <aop:pointcut > | 定义切点 | + +### 4、实现 + +假设有一个演员类`Actor`，演员类中有一个表演方法`perform()`,然后还有一个观众类`Audience`,这两个类都在包`com.example.springtest`下，Audience类主要方法如下： + +```java +public class Audience{ + //搬凳子 + public void takeSeats(){} + //欢呼 + public void applaud(){} + //计时，环绕通知需要一个ProceedingJoinPoint参数 + public void timing(ProceedingJoinPoint joinPoint){ + joinPoint.proceed(); + } + //演砸了 + public void demandRefund(){} + //测试带参数 + public void dealString(String word){} + +} +``` + +#### a、xml配置实现 + +  首先将Audience配置到springIOC中: + +```xml + +``` + +然后申明通知： + +```xml + + + + + + + + + + + + + + + + + + +``` + + + +#### b、注解实现 + +直接在Audience类上加注解（Aspect注解并不能被spring自动发现并注册，要么写到xml中，要么使用@Aspectj注解或者加一个@Component注解），如下所示： + +```java +@Aspect +public class Audience{ + //定义切点 + @Pointcut(execution(* com.example.springtest.Performer.perform(..))) + public void perform(){} + + //定义带参数切点 + @Pointcut(execution(* com.example.springtest.Performer.performArg(String) and args(word))) + public void performStr(String word){} + + //搬凳子 + @Before("perform()") + public void takeSeats(){} + + //欢呼 + @AfterReturning("perform()") + public void applaud(){} + + //计时，环绕通知需要一个ProceedingJoinPoint参数 + @Around("perform()") + public void timing(ProceedingJoinPoint joinPoint){ + joinPoint.proceed(); + } + + //演砸了 + @AfterThrowing("perform()") + public void demandRefund(){} + + //带参数 + @Before("performStr(word)") + public void dealString(String word){} +} +``` + +#### c、通过切面引入新功能 + +  既然可以用AOP为对象拥有的方法添加新功能，那为什么不能为对象增加新的方法呢？利用被称为**引入**的AOP概念，切面可以为Spring Bean添加新的方法，示例图如下： + +![引入](./picFolder/引入新功能.png) + +当引入接口的方法被调用时，代理将此调用委托给实现了新接口的某个其他对象。实际上，Bean的实现被拆分到了多个类。 + +- xml引入需要使用<aop:declare-parents >元素： + + ```xml + + + + ``` + + 顾名思义\<declare-parents>声明了此切面所通知的Bean在它的对象层次结构中有了新的父类型。其中types-matching指定增强的类；implement-interface指定实现新方法的接口；default-imple指定实现了implement-interface接口的实现类，也可以用delegate-ref来指定一个Bean的引用。 + +- 注解引入，通过`@DeclareParents`注解 + + ```xml + @DeclareParents(value="com.fxb.springtest.Performer+", + defaultImpl=AddTestImpl.class) + public static AddTestInterface addTestInterface; + ``` + + 同xml实现一样，注解也由三部分组成：1、value属性相当于tpes-matching属性，标识被增强的类；2、defaultImpl等同于default-imple，指定接口的实现类；3、有@DeclareParents注解所标注的static属性指定了将被引入的接口。 + diff --git a/spring/3.面向切面的Spring/切面示例.png b/spring/picFolder/切面示例.png similarity index 100% rename from spring/3.面向切面的Spring/切面示例.png rename to spring/picFolder/切面示例.png diff --git a/spring/3.面向切面的Spring/引入新功能.png b/spring/picFolder/引入新功能.png similarity index 100% rename from spring/3.面向切面的Spring/引入新功能.png rename to spring/picFolder/引入新功能.png diff --git a/springboot系列/springboot搭建.md b/springboot系列/springboot搭建.md deleted file mode 100644 index d923c71..0000000 --- a/springboot系列/springboot搭建.md +++ /dev/null @@ -1,48 +0,0 @@ -  前面的博客有说到spring boot搭建见另一篇博文，其实那篇博文还没写，现在来填个坑。我们使用spring initializr来构建，idea和eclipse都支持这种方式，构建过程类似，这里以idea为例，详细记录构建过程。 - -###1.选择spring initializr - -![1532967570728](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532967570728.png) - -next - -#### 2.设置参数 - -![1532967772110](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532967772110.png) - -next - -#### 3.选择依赖 - -  在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖 - -![1532967938985](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532967938985.png) - -这里我们选择web搭建一个简单的REST风格demo。然后next。 - -####4.设置项目存放地址 - -![1532968024509](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532968024509.png) - -这样就成功构建了一个springboot项目。 - -#### 5.测试 - -  现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下： - -![1532969025023](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532969025023.png) - -HelloController代码如下： - -```java -@RestController -@RequestMapping("/home") -public class HelloController{ - @GetMapping("/hello") - public String sayHello(){ - return "hello"; - } -} -``` - -然后运行项目，访问localhost:8080/home/hello即可看到hello字符串。 \ No newline at end of file diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532967570728.png b/springboot系列/springboot搭建/picFolder/1532967570728.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532967570728.png rename to springboot系列/springboot搭建/picFolder/1532967570728.png diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532967772110.png b/springboot系列/springboot搭建/picFolder/1532967772110.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532967772110.png rename to springboot系列/springboot搭建/picFolder/1532967772110.png diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532967825469.png b/springboot系列/springboot搭建/picFolder/1532967825469.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532967825469.png rename to springboot系列/springboot搭建/picFolder/1532967825469.png diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532967938985.png b/springboot系列/springboot搭建/picFolder/1532967938985.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532967938985.png rename to springboot系列/springboot搭建/picFolder/1532967938985.png diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532968024509.png b/springboot系列/springboot搭建/picFolder/1532968024509.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532968024509.png rename to springboot系列/springboot搭建/picFolder/1532968024509.png diff --git a/springboot系列/springboot搭建/springboot搭建.assets/1532969025023.png b/springboot系列/springboot搭建/picFolder/1532969025023.png similarity index 100% rename from springboot系列/springboot搭建/springboot搭建.assets/1532969025023.png rename to springboot系列/springboot搭建/picFolder/1532969025023.png diff --git a/springboot系列/springboot搭建/springboot搭建.md b/springboot系列/springboot搭建/springboot搭建.md index 0c60b29..4832fcd 100644 --- a/springboot系列/springboot搭建/springboot搭建.md +++ b/springboot系列/springboot搭建/springboot搭建.md @@ -2,13 +2,13 @@ ###1.选择spring initializr -![1532967570728](.\springboot搭建.assets\1532967570728.png) +![1532967570728](./picFolder/1532967570728.png) next #### 2.设置参数 -![1532967772110](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532967772110.png) +![1532967772110](./picFolder/1532967772110.png) next @@ -16,13 +16,13 @@ next   在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖 -![1532967938985](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532967938985.png) +![1532967938985](./picFolder/1532967938985.png) 这里我们选择web搭建一个简单的REST风格demo。然后next。 ####4.设置项目存放地址 -![1532968024509](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532968024509.png) +![1532968024509](./picFolder/1532968024509.png) 这样就成功构建了一个springboot项目。 @@ -30,7 +30,7 @@ next   现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下： -![1532969025023](D:\笔记\markdown\springboot系列\springboot搭建.assets\1532969025023.png) +![1532969025023](./picFolder/1532969025023.png) HelloController代码如下： diff --git a/springboot系列/springsecurity/picFolder/pic1.png b/springboot系列/springsecurity/picFolder/pic1.png new file mode 100644 index 0000000..454f4b6 Binary files /dev/null and b/springboot系列/springsecurity/picFolder/pic1.png differ diff --git a/springboot系列/springsecurity/picFolder/pic2.png b/springboot系列/springsecurity/picFolder/pic2.png new file mode 100644 index 0000000..9d3e516 Binary files /dev/null and b/springboot系列/springsecurity/picFolder/pic2.png differ diff --git a/springboot系列/springsecurity/springboot+security整合1.md b/springboot系列/springsecurity/springboot+security整合1.md index aaee3fc..3546a08 100644 --- a/springboot系列/springsecurity/springboot+security整合1.md +++ b/springboot系列/springsecurity/springboot+security整合1.md @@ -61,7 +61,7 @@ public class SecurityConfig extends WebSecurityConfigurerAdapter { ``` #### 2、 个性化登录，security中的登录如下： -![img][flow] +![登录过程](./picFolder/pic1.png) - security需要一个user的实体类实现`UserDetails`接口,该实体类最后与系统中用户的实体类分开，代码如下： ```java public class SecurityUser implements UserDetails{ @@ -250,19 +250,4 @@ dataSource为@Autowired引入 .rememberMeServices(rememberMeServices()) .key("INTERNAL_SECRET_KEY") ``` -在登录表单中设置remember-me即可实现记住我功能。 - - - - - - - - - - - - - - -[flow]:data:image/jpeg;base64,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 \ No newline at end of file +在登录表单中设置remember-me即可实现记住我功能。 \ No newline at end of file diff --git a/springboot系列/springsecurity/springboot+security整合3.md b/springboot系列/springsecurity/springboot+security整合3.md index 8ee3105..b3ad0bc 100644 --- a/springboot系列/springsecurity/springboot+security整合3.md +++ b/springboot系列/springsecurity/springboot+security整合3.md @@ -1,5 +1,5 @@   这篇讲解如何自定义鉴权过程，实现根据数据库查询出的url和method是否匹配当前请求的url和method来决定有没有权限。security鉴权过程如下： -![鉴权流程][鉴权流程] +![鉴权流程](./picFolder/pic2.png) ##一、 重写metadataSource类 @@ -213,23 +213,4 @@ public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor imp ```java .addFilterBefore(urlFilterSecurityInterceptor,FilterSecurityInterceptor.class) ``` -完成 - - - - - - - - - - - - - - - - - - -[鉴权流程]:data:image/jpeg;base64,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 \ No newline at end of file +完成 \ No newline at end of file diff --git a/springboot系列/数据库/picFolder/pic1.png b/springboot系列/数据库/picFolder/pic1.png new file mode 100644 index 0000000..5d6c5eb Binary files /dev/null and b/springboot系列/数据库/picFolder/pic1.png differ diff --git a/springboot系列/数据库/picFolder/pic2.png b/springboot系列/数据库/picFolder/pic2.png new file mode 100644 index 0000000..d5a1b00 Binary files /dev/null and b/springboot系列/数据库/picFolder/pic2.png differ diff --git a/springboot系列/数据库/picFolder/pic3.png b/springboot系列/数据库/picFolder/pic3.png new file mode 100644 index 0000000..ae72463 Binary files /dev/null and b/springboot系列/数据库/picFolder/pic3.png differ diff --git a/springboot系列/数据库/picFolder/pic4.png b/springboot系列/数据库/picFolder/pic4.png new file mode 100644 index 0000000..81bb700 Binary files /dev/null and b/springboot系列/数据库/picFolder/pic4.png differ diff --git a/springboot系列/数据库/springboot整合mybatis.md b/springboot系列/数据库/springboot整合mybatis.md index f3cdc53..7d4d887 100644 --- a/springboot系列/数据库/springboot整合mybatis.md +++ b/springboot系列/数据库/springboot整合mybatis.md @@ -87,7 +87,7 @@ ​ 然后依照上面的pom文件，补齐缺少的依赖。接着创建包entity，service和mybatis映射文件夹mapper，创建。为了方便配置将application.properties改成application.yml。由于我们时REST接口，故不需要static和templates目录。修改完毕后的项目结构如下： -![pic][pic1] +![项目结构](./picFolder/pic1.png) ​ 修改启动类，增加`@MapperScan("com.example.mybatistest.dao") `,以自动扫描dao目录，避免每个dao都手动加`@Mapper`注解。代码如下： @@ -320,17 +320,17 @@ public class UserController { - 插入数据： -![插入][insert] +![插入](./picFolder/pic2.png) - 查询数据 -![查询][select] +![查询](./picFolder/pic3.png) - 分页查询 - ![分页查询][selectPage] + ![分页查询](./picFolder/pic4.png) @@ -359,28 +359,4 @@ public interface UserDao { ``` 如果对你有帮助记得点赞、收藏哦！ -``` - - - - - - - - - - - - - -[pic1]:data:image/png;base64,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 -[insert]:data:image/jpeg;base64,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 - - - -[select]:data:image/jpeg;base64,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 - - - -[selectPage]:data:image/jpeg;base64,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 - +``` \ No newline at end of file diff --git a/springboot系列/消息队列/picFolder/pic1.png b/springboot系列/消息队列/picFolder/pic1.png new file mode 100644 index 0000000..5777f11 Binary files /dev/null and b/springboot系列/消息队列/picFolder/pic1.png differ diff --git a/springboot系列/消息队列/picFolder/pic2.png b/springboot系列/消息队列/picFolder/pic2.png new file mode 100644 index 0000000..f56e448 Binary files /dev/null and b/springboot系列/消息队列/picFolder/pic2.png differ diff --git a/springboot系列/消息队列/picFolder/pic3.png b/springboot系列/消息队列/picFolder/pic3.png new file mode 100644 index 0000000..875c341 Binary files /dev/null and b/springboot系列/消息队列/picFolder/pic3.png differ diff --git a/springboot系列/消息队列/springboot整合activeMQ（1）.md b/springboot系列/消息队列/springboot整合activeMQ（1）.md index 342f723..469ae37 100644 --- a/springboot系列/消息队列/springboot整合activeMQ（1）.md +++ b/springboot系列/消息队列/springboot整合activeMQ（1）.md @@ -22,7 +22,7 @@ spring: ``` ###  2. 创建生产者消费者   springboot中activeMQ的默认配置为**生产-消费者模式**，还有一种模式为**发布-订阅模式**后面再讲。项目目录如下： - ![项目目录][pic1] + ![项目目录](./picFolder/pic1.png)   首先编写配置类Config.java，代码如下 ```java @@ -40,7 +40,7 @@ public class Config { } ``` 上面的代码建立了两个消息队列queue1，queue2,分别由queue1和queue2这两个Bean注入到Spring容器中。程序运行后会在activeMQ的管理页面->queue中看到如下： -![队列][quenes] +![队列](./picFolder/pic2.png)   生产者Producer.java代码如下： ```java @@ -109,57 +109,5 @@ public class Comsumer { 1I'm from queue1:nihao ``` 消息都成功被消费者消费，从打印结果也可看出生产者消费者的一个特点：一个消息只会被一个消费者消费。同时在管理页面中可以看到： -![运行结果][quenes1] -每个消息队列有两个消费者，队列进入了三个消息，出了三个消息，说明消息都被消费掉了，如果注释掉消费者代码，再次运行，然后发送消息就会发现MessagesEnqueued数量大于MessagesDequeued，然后再让消费者上线会立即消费掉队列中的消息。 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -[quenes1]:data:image/png;base64,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 - -[quenes]:data:image/png;base64,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 - - -[pic1]:data:image/png;base64,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 \ No newline at end of file +![运行结果](./picFolder/pic3.png) +每个消息队列有两个消费者，队列进入了三个消息，出了三个消息，说明消息都被消费掉了，如果注释掉消费者代码，再次运行，然后发送消息就会发现MessagesEnqueued数量大于MessagesDequeued，然后再让消费者上线会立即消费掉队列中的消息。 \ No newline at end of file diff --git a/springboot系列/读写分离配置/读写分离配置/pic1.png b/springboot系列/读写分离配置/picFolder/pic1.png similarity index 100% rename from springboot系列/读写分离配置/读写分离配置/pic1.png rename to springboot系列/读写分离配置/picFolder/pic1.png diff --git a/springboot系列/读写分离配置/读写分离配置/pic2.png b/springboot系列/读写分离配置/picFolder/pic2.png similarity index 100% rename from springboot系列/读写分离配置/读写分离配置/pic2.png rename to springboot系列/读写分离配置/picFolder/pic2.png diff --git a/springboot系列/读写分离配置/读写分离配置/pic3.png b/springboot系列/读写分离配置/picFolder/pic3.png similarity index 100% rename from springboot系列/读写分离配置/读写分离配置/pic3.png rename to springboot系列/读写分离配置/picFolder/pic3.png diff --git a/springboot系列/读写分离配置/springboot配置读写分离.md b/springboot系列/读写分离配置/springboot配置读写分离.md index e37054a..ad595ae 100644 --- a/springboot系列/读写分离配置/springboot配置读写分离.md +++ b/springboot系列/读写分离配置/springboot配置读写分离.md @@ -33,7 +33,7 @@ 然后重启数据库，使用`show master status;`语句查看主库状态，如下所示： -![主库状态](.\读写分离配置\pic1.png) +![主库状态](./picFolder/pic1.png) - 从库配置 @@ -59,7 +59,7 @@ 接着运行`start slave;`开启备份,正常情况如下图所示：Slave_IO_Running和Slave_SQL_Running都为yes。 - ![1536223020742](.\读写分离配置\pic2.png) + ![1536223020742](./picFolder/pic2.png) 可以用这个步骤开启多个从库。 @@ -306,6 +306,6 @@ public class ReadOnlyInterceptor implements Ordered {   编写好代码来试试结果如何，下面是运行截图： -![1536312274474](.\读写分离配置\pic3.png) +![1536312274474](./picFolder/pic3.png)   断断续续写了好几天终于是写完了，，，如果有帮助到你，，欢迎star哦，，这里是完整代码地址：[点击跳转](https://github.com/FleyX/demo-project/tree/master/dxfl) \ No newline at end of file diff --git a/其他各种/git crlf、lf自动转换引起的问题.md b/其他各种/git crlf、lf自动转换引起的问题.md new file mode 100644 index 0000000..430daec --- /dev/null +++ b/其他各种/git crlf、lf自动转换引起的问题.md @@ -0,0 +1,17 @@ +  项目组最近加了一个新功能到代码中，使用flyway记录数据库版本变更，，，该工具会记录每次数据库结构的修改并生成sql文件存在指定目录上（当然必须用它来变更数据库，外部的变更它是无法感知的），然后每次启动时flyway会检查使用的数据库和当前项目代码中的sql变更版本是否一致，一致正常启动，不一致中如果是数据库落后将会更新数据库（这样能够保证代码在任何地方运行数据库都是一致的),否则就报错了。数据库中有一张表记录版本信息，如下图： + +![版本记录](./picFolder/版本记录.PNG),同时本地代码中也有一个文件夹保存每次操作的sql语句，如下图： + +![版本sql](./picFolder/版本sql.PNG) + +通过对比checksum值来判断当前sql语句和生成数据库的执行语句是否一致，checksum值由CRC32计算后处理得出。 + +  然后问题就来了，组中的其他人搭建好flyway后，项目文件生成了两个sql文件，我用git拉下来后启动报错，checkupsum值对不上，，然后我又不懂这个flyway完全不知道咋回事，然后就根据报错的位置一点点找到checkup值生成的代码，发现是CRC32计算的，，（就这么搞了一两个小时才发现是文件不一致了），但是都是从git拉的怎么就我不一致呢？？？想到可能是文件换行符的问题，遂把那几个sql文件的文件换行符全换成了crlf（windows中的换行符），然后居然就能够运行。。。关于为啥都从git拉取的文件换行符会不一样原因是：他们都用的那个小乌龟的可视化，我用的命令行。可视化工具自动配置了文件换行符的自动转换（这是git的一个智能功能，上传时将文件换行符替换为lf，，拉取时再替换为crlf，，这样保证中心仓库使用UNIX风格的换行符，，本地能够根据运行环境使用相对应的换行符风格），但是命令行并没有配置。 + +  解决办法也很简单，开启git 的自动转换。 + +``` +git config --global core.autocrlf true //开启换行符自动转换 +git config --global core.safecrlf true //禁止混用换行符 +``` + diff --git a/其他各种/java导出EXCEL文件.md b/其他各种/java导出EXCEL文件.md new file mode 100644 index 0000000..f1dd3c0 --- /dev/null +++ b/其他各种/java导出EXCEL文件.md @@ -0,0 +1,177 @@ +## 一、背景 + +  最近在java上做了一个EXCEL的导出功能，写了一个通用类，在这里分享分享，该类支持多sheet，且无需手动进行复杂的类型转换，只需提供三个参数即可： + +- `fileName` + + excel文件名 + +- `HasMap> data` + + 具体的数据，每个List代表一张表的数据，？表示可为任意的自定义对象 + +- `LinkedHashMap headers` + + `Stirng`代表sheet名。每个`String[][] `代表一个sheet的定义，举个例子如下： + + ```java + String[][] header = { + {"field1","参数1"} + ，{"field2","参数2"} + ，{"field3","参数3"} + } + ``` + + 其中的field1，field2，field3为对象中的属性名，参数1，参数2，参数3为列名，实际上这个指定了列的名称和这个列用到数据对象的哪个属性。 + +## 二、怎么用 + +  以一个例子来说明怎么用，假设有两个类A和B定义如下： + +```java +public class A{ + private String name; + private String address; +} +public class B{ + private int id; + private double sum; + private String cat; +} +``` + +现在我们通过查询数据库获得了A和B的两个列表： + +```java +List dataA = .....; +List dataB = .....; +``` + +我们将这两个导出到excel中，首先需要定义sheet： + +```java +String[][] sheetA = { + {"name","姓名"} + ,{"address","住址"} +} +String[][] sheetB = { + {"id","ID"} + ,{"sum","余额"} + ,{"cat","猫的名字"} +} +``` + +然后将数据汇总构造一个ExcelUtil： + +```java +String fileName = "测试Excel"; +HashMap> data = new HashMap<>(); +//ASheet为表名，后面headers里的key要跟这里一致 +data.put("ASheet",dataA); +data.put("BSheet",dataB); +LinkedHashMap headers = new LinkedHashMap<>(); +headers.put("ASheet",sheetA); +headers.put("BSheet",sheetB); +ExcelUtil excelUtil = new ExcelUtil(fileName,data,headers); +//获取表格对象 +HSSFWorkbook workbook = excelUtil.createExcel(); +//这里内置了一个写到response的方法（判断浏览器类型设置合适的参数），如果想写到文件也是类似的 +workbook.writeToResponse(workbook,request,response); +``` + +当然通常数据是通过数据库查询的，这里为了演示方便没有从数据库查找。 + +## 三、实现原理 + +  这里简单说明下实现过程，从调用`createExcel()`这里开始 + +####1、遍历headers创建sheet + +```java + public HSSFWorkbook createExcel() throws Exception { + try { + HSSFWorkbook workbook = new HSSFWorkbook(); + //遍历headers创建表格 + for (String key : headers.keySet()) { + this.createSheet(workbook, key, headers.get(key), this.data.get(key)); + } + return workbook; + } catch (Exception e) { + log.error("创建表格失败:{}", e.getMessage()); + throw e; + } + } +``` + +将workbook，sheet名，表头数据，行数据传入crateSheet方法中创建sheet。 + +#### 2、创建表头 + +  表头也就是一个表格的第一行，通常用来对列进行说明 + +```java + HSSFSheet sheet = workbook.createSheet(sheetName); + // 列数 + int cellNum = header.length; + // 单元行，单元格 + HSSFRow row; + HSSFCell cell; + // 表头单元格样式 + HSSFCellStyle columnTopStyle = this.getColumnTopStyle(workbook); + // 设置表头 + row = sheet.createRow(0); + for (int i = 0; i < cellNum; i++) { + cell = row.createCell(i); + cell.setCellStyle(columnTopStyle); + String str = header[i][1]; + cell.setCellValue(str); + // 设置列宽为表头的文字宽度+6个半角符号宽度 + sheet.setColumnWidth(i, (str.getBytes("utf-8").length + 6) * 256); + } +``` + +#### 3、插入行数据 + +  这里是最重要的部分，首先通过数据的类对象获取它的反射属性Field类，然后将属性名和Field做一个hash映射，避免循环查找，提高插入速度，接着通过一个switch语句，根据属性类别设值，主要代码如下： + +```java +/** + * 设置单元格,根据fieldName获取对应的Field类，使用反射得到值 + * + * @param cell 单元格实例 + * @param obj 存有属性的对象实例 + * @param fieldMap 属性名与Field的映射 + * @param fieldName 属性名 + */ +private void setCell(HSSFCell cell, Object obj, Map fieldMap, String fieldName) throws Exception { + //获取该属性的Field对象 + Field field = fieldMap.get(fieldName); + //通过反射获取属性的值，由于不能确定该值的类型，用下面的判断语句进行合适的转型 + Object value = field.get(obj); + if (value == null) { + cell.setCellValue(""); + } else { + switch (field.getGenericType().getTypeName()) { + case "java.lang.String": + cell.setCellValue((String) value); + break; + case "java.lang.Integer": + case "int": + cell.setCellValue((int) value); + break; + case "java.lang.Double": + case "double": + cell.setCellValue((double) value); + break; + case "java.util.Date": + cell.setCellValue(this.dateFormat.format((Date) value)); + break; + default: + cell.setCellValue(obj.toString()); + } + } +} +``` +完整代码可以到github上查看下载，这里就不列出来了。 + +github地址：[点击跳转]() \ No newline at end of file diff --git a/其他各种/picFolder/版本sql.PNG b/其他各种/picFolder/版本sql.PNG new file mode 100644 index 0000000..6028ac9 Binary files /dev/null and b/其他各种/picFolder/版本sql.PNG differ diff --git a/其他各种/picFolder/版本记录.PNG b/其他各种/picFolder/版本记录.PNG new file mode 100644 index 0000000..163e780 Binary files /dev/null and b/其他各种/picFolder/版本记录.PNG differ diff --git a/其他各种/正则表达式在密码匹配中的使用.md b/其他各种/正则表达式在密码匹配中的使用.md new file mode 100644 index 0000000..ccc0bb2 --- /dev/null +++ b/其他各种/正则表达式在密码匹配中的使用.md @@ -0,0 +1,48 @@ +##一、背景 + +  今天领导让我写几个正则表达式来对密码做强度验证，听到写正则表达式内心是这样的感觉（哈哈，三分钟搞定，今天又可以打鱼了）。需求如下：密码组成只能是**数字**，**字母**，**英文可见半角符号**，然后需要如下4个表达式: + +- 长度6位及以上 +- 长度6位及以上，包含数字，包含字母 +- 长度6位及以上，包含数字，包含字母，包含半角符号 +- 长度六位及以上，包含数字，包含大写字母，包含小写字母，包含半角符号 + +  看完需求我就有点懵了，包含数字或者字母我会写，但是同时存在还要在一个表达式中就有点懵了。 + +##二、解决方法 + +  以第三种为例，这个可以分解为如下需求： + +- 存在数字 +- 存在字母 +- 存在半角符号 +- 长度六位及以上 + +关键是如何同时满足前三个条件，在我有限的知识里并不知道怎么搞，然后只好求助于万能的百度了，最终在找了几个小时后发现如下几个关键词，来源[菜鸟教程](http://www.runoob.com/java/java-regular-expressions.html) ： + +- (?=*pattern*) ：正向预测先行搜索 + + 名字看着高大上，不明所以，看完示例大概明白什么意思，这个表达式匹配从这个表达式起始的字符串（我也不知道咋解释），就是假设这样一个表达式abc(?=[abc]) ,用它来匹配abc123字符串，(?=[abc])只会对作用于后面的123，这个显然是不匹配的后整个就不匹配了，然后关键来了名字里有**预测**两个字，这两个字表名了这个表达式的特性：不占用字符，匹配后如果匹配成功就继续匹配了好像从来不存在这个东西一样，匹配失败就立即返回失败了。利用这个特性我们就可以给正则加限制条件了。 + +- (?!*pattern*) ：反向预测先行搜索 + + 概念和上面一样，但是效果是相反的，abc(?![abc]),对于abc123是匹配成功的，对于abca匹配失败，如下所示： + + ```javascript + reg = /abc(?![abc])/; + reg.test("abc123") + //返回true + reg.test("abca") + //返回false + ``` + +  有了上面的知识就能搞定需求啦。 + +## 三、结果 + +  对于存在字母我们可以用这样的表达式`(?=.\*?[a-zA-Z]+.\*?),来检查是否存在至少一个字母，最后对于需求3的表达式如下：(半角字符我用的ASCII码里的16进制表示的) + +```javascript +^(?=.*?\d+.*?)(?=.*?[a-zA-Z]+.*?)(?=.*?[\x21-\x2F\x3A-\x40\x5B-\x60\x7B-\x7E]+.*?)[\da-zA-Z\x21-\x2F\x3A-\x40\x5B-\x60\x7B-\x7E]{6,}$ +``` + diff --git a/其他各种/毕设.md b/其他各种/毕设.md new file mode 100644 index 0000000..c0fd806 --- /dev/null +++ b/其他各种/毕设.md @@ -0,0 +1,452 @@ +  毕业才刚刚两个多月而已，现在想想大学生活是那么的遥不可及，感觉已经过了好久好久，社会了两个月才明白学校的好啊。。。额，扯远了，自从毕业开始就想找个时间写下毕设的记录总结，结果找了好久好久到今天才开始动笔。 + +  我的毕业设计题目是：教学辅助系统的设计与实现，，是不是很俗。。。至于为啥是这个题目呢，完全是被导师坑了。。。。。 + +## 1、需求分析 + +  拿到这个题目想着这个可能被做了无数次了，就像着哪里能够做出点创新，，最后强行创新出了一个个性化组题（根据学生水平出题）和徽章激励（达到某个要求给予一个徽章）。最后就产生了如下需求，系统有学生端和管理端： + +学生端： + +- 个人资料设置 +- 徽章激励机制 +- 查看课程信息，下载课程资料 +- 知识点检测及针对性训练 +- 在线作业，考试 +- 在线答疑，向老师或者学生提问 + +管理端： + +- 课程管理，用户管理（需要管理员权限） +- 课程信息管理 +- 课程公告管理 +- 题库管理，支持单选，多选，填空，编程题，支持题目编组 +- 发布作业，包括个性组题和手动组题 +- 发布考试，包括随机出题和手动出题 +- 自动判题，支持编程题判重 +- 在线答疑，给学生解答 +- 统计分析，包含测试统计和课程统计 + +洋洋洒洒需求列了一大堆，后面才发现是给自己挖坑，，答辩老师一看这类的题目就不感兴趣了，不论你做的咋样（况且我的演讲能力真的很一般），最后累死累活写了一大堆功能也没太高的分，，不过倒是让我的系统设计能力和代码能力有了不少的提高。 + +## 2、架构选择 + +  大三的时候了解到Node.js这个比较“奇葩"的异步语言，再加上在公司实习了三个月也是用的node开发，对node已经比较熟悉了，于是就用它做了后台，前端用最近比较火的vue.js做单页应用。当时还想着负载均衡啥的，就没有用传统的session，cookie机制，转而用jwt做的基于token的身份认证，同时后台接口也是类Restful风格的（因为纯正的Rest接口太难设计了）。 + +总的来说后台用了以下技术和框架： + +  总的来说后台用了以下技术和框架： + +- 语言：Node.js +- web框架：kOA +- 前后台传输协议：jwt +- 缓存：redis +- 数据库：mysql +- 编程题判题核心：[青岛大学OJ判题核心](https://github.com/QingdaoU/JudgeServer) +- 代码判重：[SIM](https://dickgrune.com/Programs/similarity_tester/) + +前台技术如下： + +- 框架：Vue.js +- UI框架：Element-UI +- 图表组件：G2 + +## 3、系统基础框架搭建 + +  本系统是前后端分离的，下面分别介绍前后端的实现基础。 + +### 1、后台 + +  一个web后台最重要的无非那么几个部分：路由；权限验证；数据持久化。 + +#### a、路由 + +KOA作为一个web框架其实它本身并没有提供路由功能，需要配合使用koa-router来实现路由，koa-router以类似下面这样的风格来进行路由： + +  KOA作为一个web框架其实它本身并没有提供路由功能，需要配合使用koa-router来实现路由，koa-router以类似下面这样的风格来进行路由： + +```javascript +const app = require("koa"); +const router = require("koa-router"); +router.get("/hello",koa=>{ + koa.response="hello"; +}); +app.use(router.routes()) +``` + +显然这样在项目中是很不方便的，如果每个路由都要手动进行挂载，很难将每个文件中的路由都挂载到一个router中。因此在参考网上的实现后，我写了一个方法在启动时自动扫描某个文件夹下所有的路由文件并挂载到router中，代码如下： + +```javascript +const fs = require('fs'); +const path = require('path'); +const koaBody = require('koa-body'); +const config = require('../config/config.js'); + +function addMapping(router, filePath) { + let mapping = require(filePath); + for (let url in mapping) { + if (url.startsWith('GET ')) { + let temp = url.substring(4); + router.get(temp, mapping[url]); + console.log(`----GET：${temp}`); + } else if (url.startsWith('POST ')) { + let temp = url.substring(5); + router.post(temp, mapping[url]); + console.log(`----POST：${temp}`); + } else if (url.startsWith('PUT ')) { + let temp = url.substring(4); + router.put(temp, mapping[url]); + console.log(`----PUT：${temp}`) + } else if (url.startsWith('DELETE ')) { + let temp = url.substring(7); + router.delete(temp, mapping[url]); + console.log(`----DELETE: ${temp}`); + } else { + console.log(`xxxxx无效路径：${url}`); + } + } +} + +function addControllers(router, filePath) { + let files = fs.readdirSync(filePath); + files.forEach(element => { + let temp = path.join(filePath, element); + let state = fs.statSync(temp); + if (state.isDirectory()) { + addControllers(router, temp); + } else { + if (!temp.endsWith('Helper.js')) { + console.log('\n--开始处理: ' + element + "路由"); + addMapping(router, temp); + } + } + }); +} + +function engine(router, folder) { + addControllers(router, folder); + return router.routes(); +} + +module.exports = engine; +``` + +然后在index.js中use此方法： + +``` +const RouterMW = require("./middleware/controllerEngine.js"); +app.use(RouterMW(router,path.join(config.rootPath, 'api'))); +``` + +然后路由文件以下面的形式编写： + +```javascript +const knowledgePointDao = require('../dao/knowledgePointDao.js'); + +/** + * 返回某门课的全部知识点,按章节分类 + */ +exports["GET /course/:c_id/knowledge_point"] = async (ctx, next) => { + let res = await knowledgePointDao.getPontsOrderBySection(ctx.params.c_id); + ctx.onSuccess(res); +} + +//返回某位学生知识点答题情况 +exports["GET /user/:u_id/course/:c_id/knowledge_point/condition"]=async(ctx,next)=>{ + let {u_id,c_id}=ctx.params; + let res = await knowledgePointDao.getStudentCondition(u_id,c_id); + ctx.onSuccess(res); +} +``` + +#### b、权限验证 + +  权限管理是一个系统最重要的部分之一，目前主流的方式为**基于角色的权限管理**， 一个用户对应多个角色，每个角色对应多个权限（本系统中每个用户对应一个身份，每个身份对应多个角色）。我们的系统如何实现的呢？先从登录开始说起，本系统抛弃了传统的cookie，session模式，使用json web token（JWT）来做身份认证，用户登录后返回一个token给客户端，代码如下所示： + +```javascript +//生成随机盐值 +let str = StringHelper.getRandomString(0, 10); +//使用该盐值生成token +let token = jwt.sign({ + u_id: userInfo.u_id, + isRememberMe +}, str, { + expiresIn: isRememberMe ? config.longTokenExpiration:config.shortTokenExpiration +}); +//token-盐值存入redis，如想让该token过期，redis中清楚该token键值对即可 +await RedisHelper.setString(token, str, 30 * 24 * 60 * 60); +res.code = 1; +res.info = '登录成功'; +res.data = { + u_type: userInfo.u_type, + u_id: userInfo.u_id, + token +}; +``` + +以后每次客户端请求都要在header中设置该token，然后每次服务端收到请求都先验证是否拥有权限，验证代码使用`router.use(auth)`,挂载到koa-router中，这样每次在进入具体的路由前都要先执行auth方法进行权限验证,主要验证代码逻辑如下： + +```javascript +/** + * 1 验证成功 + * 2 登录信息无效 401 + * 3 已登录，无操作权限 403 + * 4 token已过期 + */ +let verify = async (ctx) => { + let token = ctx.headers.authorization; + if (typeof (token) != 'string') { + return 2; + } + let yan = await redisHelper.getString(token); + if (yan == null) { + return 2; + } + let data; + try { + data = jwt.verify(token, yan); + } catch (e) { + return 2; + } + if (data.exp * 1000 < Date.now()) { + return 4; + } + //判断是否需要刷新token，如需要刷新将新token写入响应头 + if (!data.isRememberMe && (data.exp * 1000 - Date.now()) < 30 * 60 * 1000) { + //token有效期不足半小时，重新签发新token给客户端 + let newYan = StringHelper.getRandomString(0, 10); + let newToken = jwt.sign({ + u_id: data.u_id, + isRememberMe:false + }, newYan, { + expiresIn: config.shortTokenExpiration + }); + // await redisHelper.deleteKey(token); + await redisHelper.setString(newToken, newYan,config.shortTokenExpiration); + ctx.response.set('new-token', newToken); + ctx.response.set('Access-Control-Expose-Headers','new-token'); + } + //获取用户信息 + let userInfoKey = data.u_id + '_userInfo'; + let userInfo = await redisHelper.getString(userInfoKey); + if (userInfo == null || Object.keys(userInfo).length != 3) { + userInfo = await mysqlHelper.first(`select u_id,u_type,j_id from user where u_id=?`, data.u_id); + await redisHelper.setString(userInfoKey, JSON.stringify(userInfo), 24 * 60 * 60); + }else{ + userInfo = JSON.parse(userInfo); + } + ctx.userInfo = userInfo; + //更新用户上次访问时间 + mysqlHelper.execute(`update user set last_login_time=? where u_id=?`,Date.now(),userInfo.u_id); + //管理员拥有全部权限 + if (userInfo.u_type == 0) { + return 1; + } + //获取该用户类型权限 + let authKey = userInfo.j_id + '_authority'; + let urls = await redisHelper.getObject(authKey); + // let urls = null; + if (urls == null) { + urls = await mysqlHelper.row(` + select b.r_id,b.url,b.method from jurisdiction_resource a inner join resource b on a.r_id = b.r_id where a.j_id=? + `, userInfo.j_id); + let temp = {}; + urls.forEach(item => { + temp[item.url + item.method] = true; + }) + await redisHelper.setObject(authKey, temp); + urls = temp; + } + //判断是否拥有权限 + if (urls.hasOwnProperty(ctx._matchedRoute.replace(config.url_prefix, '') + ctx.method)) { + return 1; + } else { + return 3; + } +} +``` + +根据用户id获取用户身份id，根据用户身份id从redis中获取拥有的权限，如为null，从mysql数据库中拉取，并存入redis中，然后判断是否拥有要访问的url权限。 + +#### c、数据持久化 + +  本系统中使用mysql存储数据，redis做缓存，由于当时操作库不支持promise，故对它两做了个promise封装，方便代码中调用，参见：[MysqlHelper](https://github.com/FleyX/teach_system/tree/master/teachSystem/util/MysqlHelper.js),[RedisHelper.js](https://github.com/FleyX/teach_system/tree/master/teachSystem/util/RedisHelper.js)。 + +### 2、前端 + +  前端使用vue-cli构建vue项目，主要用到了vue-router,element-ui,axios这三个组件。 + +#### a、路由组织 + +  单页应用需要前端自己组织路由。本系统将路由分成了三个部分：公共，管理端，学生端。index.js如下： + +```javascript +export default new Router({ + mode: 'history', + base: '/app/', + routes: [{ + path: '', + name: 'indexPage', + component: IndexPage + }, + { + path: '/about', + name: 'about', + component: About + }, + Admin, + Client, + Public, + { + path: '*', + name: "NotFound", + component: NotFound + } + ] +}) +``` + +其中的Admin，Client，Public分别为各部分的路由，以子路由的形式一级级组织。如下所示： + +```javascript +export default { + path: "/client", + component: Client, + beforeEnter: (to, from, next) => { + if (getClientUserInfo() == null) { + next({ + path: '/public/client_login', + replace: true, + }) + } else { + next(); + } + }, + children: [{ + //学生端主页 + path: '', + name: "ClientMain", + component: ClientHome + }, { + //学生个人资料页面 + path: 'person/student_info', + name: "StudentInfo", + component: StudentInfo + }, { + //公告页面 + path: 'course/:c_id/announcement', + name: 'Main', + component: Announcement + }, { + //课程基本信息 + path: 'course/:c_id/base', + component: ClientMain, + children: [{ + path: 'course_intro', + name: "ClientCourseIntro", + component: CourseIntro + }, { + path: 'exam_type', + name: "ClientExamType", + component: ExamType + } + ...... +``` + +其中的beforEnter为钩子函数，每次进入路由时执行该函数，用于判断用户是否登录。这里涉及到了一个前端鉴权的概念，由于前后端分离了，前端也必须做鉴权以免用户进入到了无权限的页面，这里我只是简单的做了登录判断，更详细的url鉴权也可实现，只需在对应的钩子函数中进行鉴权操作，更多关于钩子函数信息[点击这里](https://router.vuejs.org/zh/guide/advanced/navigation-guards.html)。 + +#### b、请求封装 + +  前端还有一个比较重要的部分是ajax请求的处理，请求处理还保护错误处理，有些错误只需要统一处理，而有些又需要独立的处理，这样一来就需要根据业务需求进行一下请求封装了，对结果进行处理后再返回给调用者。我的实现思路是发起请求，收到响应后先对错误进行一个同意弹窗提示，然后再将错误继续向后传递，调用者可选择性的捕获错误进行针对性处理，主要代码如下： + +```javascript +request = (url, method, params, form, isFormData, type) => { + let token; + if (type == 'admin') + token = getToken(); + else + token = getClientToken(); + let headers = { + 'Authorization': token + }; + if (isFormData) { + headers['Content-Type'] = "multipart/form-data"; + } + return new Promise((resolve, reject) => { + axios({ + url, + method, + params, + data: form, + headers, + // timeout:2000 + }).then(res => { + resolve(res.data); + //检查是否有更新token + // console.log(res); + if (res.headers['new-token'] != undefined) { + console.log('set new token'); + if (vm.$route.path.startsWith('/admin')){ + localStorage.setItem("token",res.headers['new-token']); + window.token = undefined; + }else if(vm.$route.path.startsWith('/client')){ + localStorage.setItem("clientToken",res.headers['new-token']); + window.clientToken = undefined; + } + } + }).catch(err => { + reject(err); + if (err.code == 'ECONNABORTED') { + alertNotify("错误", "请求超时", "error"); + return; + } + if (err.message == 'Network Error') { + alertNotify("错误", "无法连接服务器", 'error'); + return; + } + if (err.response != undefined) { + switch (err.response.status) { + case 401: + if (window.isGoToLogin) { + return; + } + //使用该变量表示是否已经弹窗提示了，避免大量未登录弹窗堆积。 + window.isGoToLogin = true; + vm.$alert(err.response.data, "警告", { + type: "warning", + showClose: false + }).then(res => { + window.isGoToLogin = false; + if (vm.$route.path.startsWith('/admin/')) { + clearInfo(); + vm.$router.replace("/public/admin_login"); + } else { + clearClientInfo(); + vm.$router.replace("/public/client_login"); + } + }); + break; + case 403: + alertNotify("Error:403", '拒绝执行：' + err.response.data, "error"); + break; + case 404: + alertNotify("Error:404", "找不到资源：" + url.substr(0, url.indexOf('?')), 'error'); + break; + case 400: + alertNotify("Error:400", "请求参数错误：" + err.response.data, 'error'); + break; + case 500: + alertNotify("Error:500", "服务器内部错误：" + err.response.data, 'error'); + default: + console.log('存在错误未处理：' + err); + } + } else { + console.log(err); + } + }) + }) +} + +``` + +  到这里就算是简单介绍完了,,想要更加深入了解的可以去github查看源代码，地址如下：[https://github.com/FleyX/teach_system，](https://github.com/FleyX/teach_system)记得star哦！ \ No newline at end of file diff --git a/数据库/分布式事务1.md b/数据库/分布式事务1.md index 7d26580..592c147 100644 --- a/数据库/分布式事务1.md +++ b/数据库/分布式事务1.md @@ -1,75 +1,75 @@ -## 前言 - -  分布式事务是企业集成中的一个技术难点，也是每一个分布式系统架构中都会涉及到的一个东西，特别是在微服务架构中，几乎是无法避免的。 - -##一、从单机事务到分布式 - -###1.数据库事务 - -​ 我们都知道数据库事务的四个特性：原子性、一致性、隔离性和持久性，数据库事务由数据库软件自身来完成。假如数据库在提交事务的时候突然断电，数据库可以在日志记录中找到上一次事务操作然后根据当前数据库的情况进行undo回滚或者是redo前滚（基于某时刻的完整备份然后执行从该时刻到崩溃时间所有增删改查操作，使数据库恢复到崩溃前的状态）。在分布式环境中可能遇到的问题就更多了，例如机器宕机、网络异常、消息乱序、数据错误、存储数据丢失等等，数据库自身并没有比较好的解决方案（下文会提到一种数据库支持的解决方法）。 - -###2.分布式理论 - -  当单个数据库的性能产生瓶颈的时候，我们可能会对数据库进行分区，这里分区指的是物理分区，分区后不同的库可能就在不同的服务器上了，这个时候单个数据库的ACID已经不能适应这种情况了，在集群情况下想保证集群的ACID是很困难的，即使能够达到，效率和性能也会大幅下降，而且难以拓展。这就需要一个新的理论**CAP原则**。 - -  CAP是加州大学伯克利分校Eric Brewer教授提出的，他指出WEB服务无法同时满足以下3个属性： - -- 一致性（Consistency):客户端发起的一系列操作都会同时生效 -- 可用性（Availability）：每个操作必须以可预期的响应结束 -- 分区容错性（Partition Tolerance）：即使单个组件无法使用，操作任然可以完成 - -具体的说在分布式系统中，任何数据库至多只能同时支持上面的两个属性，但是任何横向拓展策略都要依赖数据分区。因此，设计人员必须在一致性与可用性中作出选择。在此基础上后面又提出了另外一个理论，**BASE**理论，用于对CAP原则进一步扩充。BASE理论指的是： - -- 基本可用（Basically Available） -- 软状态（Soft State） -- 最终一致性（Eventually Consistent) - -BASE理论是对CAP中的一致性和可用性进行一个权衡的结果，理论的核心思想就是：**我们没法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性**。 - -## 二、解决方案 - -### 1.两阶段提交（2PC） - -​ 主流关系型数据库大都支持，又叫**XA Transactions(XAT)**。其中XA是一个两阶段提交协议，该协议分为以下两个阶段： - -- 第一阶段：事务协调器要求每个涉及到事务的数据库预提交（precommit）此操作，并反映是否可以提交 -- 第二阶段：事务协调器要求每个数据库提交数据 - -其中，在第一阶段如果有任何一个数据库否决此次提交，那么所有数据库都会被要求回滚它们在此次事务中的那部分信息。通俗的说在进行一次事务操作时，事务管理器会先询问每个用到的数据库能不能操作成功（数据库进行一次预操作看能否成功），如果任意一个说操作失败，所有的数据库都回滚预操作。 - -**优点**：尽量保证了数据的强一致 - -**缺点**：实现复杂，可用性降低，同时对性能影响很大 - -### 2.补偿事务（TCC） - -​ 核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。它分为三个阶段： - -- Try阶段主要对业务系统做检测及资源预留 -- Confirm阶段主要对业务系统做确认提交，Try阶段执行成功然后开始执行Confirm阶段时，默认Confirm阶段是不会出错的。也就是只要Try成功，Confirm一定成功。 -- Cancel阶段主要在业务执行错误，需要回滚的状态下执行的业务取消，预留资源释放。 - -**优点**：跟2PC比起来，实现以及流程相对简单了点，但是数据的一致性也差一点 - -**缺点**：在第二阶段、第三阶段都由可能失败。对业务代码入侵比较严重，需要在实现的时候多写很多补偿代码。 - -### 3.本地消息表（异步补偿） - -​ 本地消息应该是业界使用最多的，其核心思想是将分布式事务拆分成本地事务进行处理，这种思路来源于ebay。 - -​ 基本思路如下： - -​ 每个分布式节点都需要额外建一个消息表。 - -​ 消息生产方，记录消息发送状态。消息表和业务数据放在一个事物里提交，然后消息经过MQ发送到消息的消费方，如果消息发送失败，进行重新发送。 - -​ 消息消费方，需要处理这个消息，并完成自己的业务逻辑，同上也要将消息记录到消息表中，此时如果本地事务处理成功，将消息通过MQ发送给下一个消费方，知道所有事物执行完毕，如果事物处理失败，可以给生产方发送一个业务补偿消息，通知生产方进行回滚等操作,生产方再向上传递，直到回到初始状态。 - -​ 生产方和消费方定时扫描本地消息表，把还没处理玩的消息或失败消息再次发送一遍，这需要一个靠谱的自动对账补账逻辑。 - -​ 这种方案遵循BASE理论，采用最终一致性，实现较为简单，性能也不错。 - -**优点**：一种非常经典的实现，避免了分布式事务，实现了最终一致性。 - -**缺点**：消息表耦合到了业务系统中。 - +## 前言 + +  分布式事务是企业集成中的一个技术难点，也是每一个分布式系统架构中都会涉及到的一个东西，特别是在微服务架构中，几乎是无法避免的。 + +##一、从单机事务到分布式 + +###1.数据库事务 + +​ 我们都知道数据库事务的四个特性：原子性、一致性、隔离性和持久性，数据库事务由数据库软件自身来完成。假如数据库在提交事务的时候突然断电，数据库可以在日志记录中找到上一次事务操作然后根据当前数据库的情况进行undo回滚或者是redo前滚（基于某时刻的完整备份然后执行从该时刻到崩溃时间所有增删改查操作，使数据库恢复到崩溃前的状态）。在分布式环境中可能遇到的问题就更多了，例如机器宕机、网络异常、消息乱序、数据错误、存储数据丢失等等，数据库自身并没有比较好的解决方案（下文会提到一种数据库支持的解决方法）。 + +###2.分布式理论 + +  当单个数据库的性能产生瓶颈的时候，我们可能会对数据库进行分区，这里分区指的是物理分区，分区后不同的库可能就在不同的服务器上了，这个时候单个数据库的ACID已经不能适应这种情况了，在集群情况下想保证集群的ACID是很困难的，即使能够达到，效率和性能也会大幅下降，而且难以拓展。这就需要一个新的理论**CAP原则**。 + +  CAP是加州大学伯克利分校Eric Brewer教授提出的，他指出WEB服务无法同时满足以下3个属性： + +- 一致性（Consistency):客户端发起的一系列操作都会同时生效 +- 可用性（Availability）：每个操作必须以可预期的响应结束 +- 分区容错性（Partition Tolerance）：即使单个组件无法使用，操作任然可以完成 + +具体的说在分布式系统中，任何数据库至多只能同时支持上面的两个属性，但是任何横向拓展策略都要依赖数据分区。因此，设计人员必须在一致性与可用性中作出选择。在此基础上后面又提出了另外一个理论，**BASE**理论，用于对CAP原则进一步扩充。BASE理论指的是： + +- 基本可用（Basically Available） +- 软状态（Soft State） +- 最终一致性（Eventually Consistent) + +BASE理论是对CAP中的一致性和可用性进行一个权衡的结果，理论的核心思想就是：**我们没法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性**。 + +## 二、解决方案 + +### 1.两阶段提交（2PC） + +​ 主流关系型数据库大都支持，又叫**XA Transactions(XAT)**。其中XA是一个两阶段提交协议，该协议分为以下两个阶段： + +- 第一阶段：事务协调器要求每个涉及到事务的数据库预提交（precommit）此操作，并反映是否可以提交 +- 第二阶段：事务协调器要求每个数据库提交数据 + +其中，在第一阶段如果有任何一个数据库否决此次提交，那么所有数据库都会被要求回滚它们在此次事务中的那部分信息。通俗的说在进行一次事务操作时，事务管理器会先询问每个用到的数据库能不能操作成功（数据库进行一次预操作看能否成功），如果任意一个说操作失败，所有的数据库都回滚预操作。 + +**优点**：尽量保证了数据的强一致 + +**缺点**：实现复杂，可用性降低，同时对性能影响很大 + +### 2.补偿事务（TCC） + +​ 核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。它分为三个阶段： + +- Try阶段主要对业务系统做检测及资源预留 +- Confirm阶段主要对业务系统做确认提交，Try阶段执行成功然后开始执行Confirm阶段时，默认Confirm阶段是不会出错的。也就是只要Try成功，Confirm一定成功。 +- Cancel阶段主要在业务执行错误，需要回滚的状态下执行的业务取消，预留资源释放。 + +**优点**：跟2PC比起来，实现以及流程相对简单了点，但是数据的一致性也差一点 + +**缺点**：在第二阶段、第三阶段都由可能失败。对业务代码入侵比较严重，需要在实现的时候多写很多补偿代码。 + +### 3.本地消息表（异步补偿） + +​ 本地消息应该是业界使用最多的，其核心思想是将分布式事务拆分成本地事务进行处理，这种思路来源于ebay。 + +​ 基本思路如下： + +​ 每个分布式节点都需要额外建一个消息表。 + +​ 消息生产方，记录消息发送状态。消息表和业务数据放在一个事物里提交，然后消息经过MQ发送到消息的消费方，如果消息发送失败，进行重新发送。 + +​ 消息消费方，需要处理这个消息，并完成自己的业务逻辑，同上也要将消息记录到消息表中，此时如果本地事务处理成功，将消息通过MQ发送给下一个消费方，知道所有事物执行完毕，如果事物处理失败，可以给生产方发送一个业务补偿消息，通知生产方进行回滚等操作,生产方再向上传递，直到回到初始状态。 + +​ 生产方和消费方定时扫描本地消息表，把还没处理玩的消息或失败消息再次发送一遍，这需要一个靠谱的自动对账补账逻辑。 + +​ 这种方案遵循BASE理论，采用最终一致性，实现较为简单，性能也不错。 + +**优点**：一种非常经典的实现，避免了分布式事务，实现了最终一致性。 + +**缺点**：消息表耦合到了业务系统中。 + diff --git a/数据库/数据库事务四个特性及隔离级别.md b/数据库/数据库事务四个特性及隔离级别.md index ec430ea..6c7bde7 100644 --- a/数据库/数据库事务四个特性及隔离级别.md +++ b/数据库/数据库事务四个特性及隔离级别.md @@ -1,45 +1,45 @@ -## 一、 数据库事务四大特性ACID - -### 1、 原子性（Atomicity） - -  原子性是指事务包含的所有操作要么全部执行成功，否则失败回滚，回到未执行事务前的状态。 - -### 2、一致性（Consistency） - -  一致性是指事务必须使数据库从一个一致性状态变成另一个一致性状态，也就是事务执行前后必须处于一致性状态。 -  以转账为例，假设用户A和B两者的钱加起来是5000，那么不管A和B之间如何转账，转多少次，事务结束后两个用户的钱加起来应该还得是5000，这就是事务的一致性。 - -### 3、 隔离性（Isolation） - -  隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其它的事务操作所干扰，多个并发事务之间要相互隔离。 - -  既要达到这么一种效果：对于任意的两个并发的事务T1和T2，它们相互之间感觉不到对方正在并发的执行，关于事务的隔离性数据库提供了多种隔离级别，假设我们不考虑隔离性会发生什么问题呢？ - -- 脏读 - - 在一个事务中对数据做了修改，但还未提交，这是其他人读取这个数据，得到的是修改后的值，一旦事务回滚了，再次读取时发现值又变了。 - -- 不可重复读 - - 不可重复读是在对数据库中的某个数据重复查询时，返回了不同的查询结果，这是由于在查询期间，被另一个事物修改并提交了。和脏读的区别是脏读读取的是另一个事物未提交的脏数据，不可重复读读取的是前一事物已提交的数据。通常情况下不可重复读并不是问题。 - -- 幻读（虚读） - - 幻读是事物非独立执行时发生的一种现象，例如事物T1对一个表中所有的行的某个数据设置为了1，这时还有一个其他操作向该表中插入了一行数据，并且数据不为1，如果操作T1的用户查看刚刚修改的数据就会发现还有一行没有修改，其实这行是在修改操作完毕后新加入的一条数据。 - -### 4、 持久性 - -  持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即使在数据库系统遇到故障的情况下也不会丢失提交事务的操作。 - -   例如我们在使用jdbc操作数据库时，在提交事务方法成功后，就可以认定事务已经被正确提交，即使数据发生重大故障，操作也会正确完成。 - -## 二、 四种隔离级别 - -  Mysql数据库提供了四种数据库的隔离级别： - -1. Serializable(串行化):对表加了读写锁，每次读写都需要获取共享锁，丧失了并发速度，可避免脏读，不可重复读，幻读的发生 -2. Repeatable read(可重复读):在同一个事务内的查询都是事务开始时刻一致的，可避免脏读、不可重复读的发生 -3. Read committed(读已提交)：只能读取到已经提交的数据，避免了脏读的发生。 -4. Read uncommitted(读未提交)：所有都能读取到，啥都无法避免 - +## 一、 数据库事务四大特性ACID + +### 1、 原子性（Atomicity） + +  原子性是指事务包含的所有操作要么全部执行成功，否则失败回滚，回到未执行事务前的状态。 + +### 2、一致性（Consistency） + +  一致性是指事务必须使数据库从一个一致性状态变成另一个一致性状态，也就是事务执行前后必须处于一致性状态。 +  以转账为例，假设用户A和B两者的钱加起来是5000，那么不管A和B之间如何转账，转多少次，事务结束后两个用户的钱加起来应该还得是5000，这就是事务的一致性。 + +### 3、 隔离性（Isolation） + +  隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其它的事务操作所干扰，多个并发事务之间要相互隔离。 + +  既要达到这么一种效果：对于任意的两个并发的事务T1和T2，它们相互之间感觉不到对方正在并发的执行，关于事务的隔离性数据库提供了多种隔离级别，假设我们不考虑隔离性会发生什么问题呢？ + +- 脏读 + + 在一个事务中对数据做了修改，但还未提交，这是其他人读取这个数据，得到的是修改后的值，一旦事务回滚了，再次读取时发现值又变了。 + +- 不可重复读 + + 不可重复读是在对数据库中的某个数据重复查询时，返回了不同的查询结果，这是由于在查询期间，被另一个事物修改并提交了。和脏读的区别是脏读读取的是另一个事物未提交的脏数据，不可重复读读取的是前一事物已提交的数据。通常情况下不可重复读并不是问题。 + +- 幻读（虚读） + + 幻读是事物非独立执行时发生的一种现象，例如事物T1对一个表中所有的行的某个数据设置为了1，这时还有一个其他操作向该表中插入了一行数据，并且数据不为1，如果操作T1的用户查看刚刚修改的数据就会发现还有一行没有修改，其实这行是在修改操作完毕后新加入的一条数据。 + +### 4、 持久性 + +  持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即使在数据库系统遇到故障的情况下也不会丢失提交事务的操作。 + +   例如我们在使用jdbc操作数据库时，在提交事务方法成功后，就可以认定事务已经被正确提交，即使数据发生重大故障，操作也会正确完成。 + +## 二、 四种隔离级别 + +  Mysql数据库提供了四种数据库的隔离级别： + +1. Serializable(串行化):对表加了读写锁，每次读写都需要获取共享锁，丧失了并发速度，可避免脏读，不可重复读，幻读的发生 +2. Repeatable read(可重复读):在同一个事务内的查询都是事务开始时刻一致的，可避免脏读、不可重复读的发生 +3. Read committed(读已提交)：只能读取到已经提交的数据，避免了脏读的发生。 +4. Read uncommitted(读未提交)：所有都能读取到，啥都无法避免 +   Mysql默认的事务隔离级别是2。 \ No newline at end of file diff --git a/网络/nat模式虚拟机主机相互ping通.md b/网络/nat模式虚拟机主机相互ping通.md new file mode 100644 index 0000000..fad5437 --- /dev/null +++ b/网络/nat模式虚拟机主机相互ping通.md @@ -0,0 +1,57 @@ +## 1、wmware设置 + +  这篇记录下nat网络模式下虚拟机与主机的相互ping通。首先使用wmware建立一个ubuntu虚拟机，网络模式选择nat模式。然后点击虚拟网络编辑： + +![1536153781962](./picFolder/pic1.png) + +接下来点击nat设置： + +![1536153954193](./picFolder/pic2.png) + +看到如下： + +![pic3](./picFolder/pic3.png) + +上面红框是关键，记录这个值，下面虚拟机设置静态ip要用到。 + +## 2、window网络设置 + +  打开网络适配器页面，选择VMnet,右键->属性->Internet协议版本 4（TCP/IPV4）->属性，设置ip地址为上面上面网关地址最后一个数改成1，比如192.168.128.2就要设置为192.168.128.1，同时设置子网掩码为255.255.255.0，默认网关不要填。我的如下： + +![pic4](./picFolder/pic4.png) + +**如果想让虚拟机能够访问主机需要关闭主机的防火墙** + +## 3、ubuntu设置 + +  编辑/etc/network/interfaces + +```bash +vim /etc/network/interfaces +# This file describes the network interfaces available on your system +# and how to activate them. For more information, see interfaces(5). + +source /etc/network/interfaces.d/* + +# The loopback network interface +auto lo +iface lo inet loopback + +# The primary network interface +auto ens33 +# dhcp 改成static，然后设置下面的address,netmask,gateway +iface ens33 inet static +address 192.168.128.129 +netmask 255.255.255.0 +gateway 192.168.128.2 +# 设置dns +dns-nameservers 192.168.128.2 + + +``` + +然后执行`/etc/init.d/networking restart`,或者重启虚拟机以启用网络设置。 + +## 3、验证 + +  现在虚拟机中`ping 192.168.128.1`可以ping通，主机中`ping 192.168.128.129`也可ping通。 \ No newline at end of file diff --git a/网络/picFolder/pic1.png b/网络/picFolder/pic1.png new file mode 100644 index 0000000..76de14f Binary files /dev/null and b/网络/picFolder/pic1.png differ diff --git a/网络/picFolder/pic2.png b/网络/picFolder/pic2.png new file mode 100644 index 0000000..132f279 Binary files /dev/null and b/网络/picFolder/pic2.png differ diff --git a/网络/picFolder/pic3.png b/网络/picFolder/pic3.png new file mode 100644 index 0000000..c9f58c1 Binary files /dev/null and b/网络/picFolder/pic3.png differ diff --git a/网络/picFolder/pic4.png b/网络/picFolder/pic4.png new file mode 100644 index 0000000..21beeb5 Binary files /dev/null and b/网络/picFolder/pic4.png differ