SpringBoot简单使用笔记_springboot exclusion

• 项目结构

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KefEFxpz-1617086101760)(./SpringBoot项目结构.bmp)]

  • SpringBoot默认两种配置文件方式 .properties和 .yml，其中properties配置文件的优先级高于 .yml

• 入口类

  需要放在包的最外层，以便能够扫描到所有子包中的类

  • @SpringBootApplication 是一个组合注解，包含 @EnableAutoConfiguration、@ComponentScan和@SpringBootConfiguration

• pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RC1</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<!--用来提供相关的Maven默认依赖，使用后，常用的依赖包可以省去version标签-->

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--该依赖中包含多个Web依赖，如spring-web、spring-webmvc等-->
1
2
3
4
5
6
7
8
9
10
11
12
13

1、集成Mysql数据库

• 依赖

<!-- mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9

• application.properties

### mysql连接信息
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
1
2
3
4
5

集成Druid

开启监控功能的方式有多种：

1. 使用原生的Servlet、Filter方式，然后通过@ServletComponentScan启动包扫描进行处理；
2. 使用代码注册Servlet和Fileter的方式处理。（配置类，Spring Boot推荐方式）

@Configuration：Spring中有很多XML配置文件，文件中会配置很多bean。在类上添加@Configuration注解，可以理解为该类变成了一个XML配置文件。（配置类）

@Bean：等同于XML配置文件中的<bean>配置。Spring Boot会把加上该注解的方法返回值装载进Spring IoC容器，方法的名称对应<bean>标签的id属性值。

2、集成Spring Data JPA

• Spring Data JPA最顶层的接口是Repository，该接口是所有Repository类的父类。
• Repository接口的子类有CrudRespository（提供了基本的增删改查等接口）、PagingAndSortingRepository（提供了基本的分页和排序等接口）、JpaRepository（是前面两个个子类，继承了它们的所有接口，一般使用此接口或其子类）

@NoRepositoryBean：使用此注解表明此接口不是一个Repository Bean

集成Spring Data JPA

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
1
2
3
4

1. 继承JpaRespository

• @Entity：每个持久化POJO类都是一个实体Bean，通过在类的定义中使用@Entiry注解来进行声明
• @Table：声明此对象映射到数据的数据表。该注解不是必须的，如果没有，系统就会使用默认值（实体的短类名）
• @Id：指定表的主键

2. Service层实现

• @Service：等同于Compoent，只是更好能表明是Service层
• @Component：泛指组件，当组件不好归类时，使用此注解进行标注
• @Repository：持久层组件，用于标注数据访问组件，即DAO组件
• @Resource：属于J2EE，
  • 默认按照名称进行装配，通过name属性指定。
  • 如果没有指定name属性，当注解写在字段上时，就默认读取字段名进行查找；
  • 如果字段写在setter方法上，就默认去属性名进行装配；
  • 当找不到与名称匹配的bean时，才按照类型进行装配。
• @Autowired：默认情况下，要求依赖对象必须存在，如果要允许null值，name可以设置她的required属性为false；如果想使用名称装配，结合@Qulifier注解使用

3、使用Thymeleaf模板引擎

在使用Spring Boot框架进行页面设计时，一般都会选用Thymeleaf模板。

常用表达式：

• ${…} 变量表达式
• *{…} 选择表达式
• @{…} 连接url表达式
• #{…} 消息文字表达式
• #maps 工具对象表达式

常用标签：

• th:action 定义后台控制器路径
• th:each 循环语句
• th:field 表单字段绑定
• th:href 定义超链接
• th:id div标签中的ID声明，类似HTML标签中的ID属性
• th:if 条件判断语句
• th:include 布局标签，替换内容到引入文件
• th:fragment 布局标签，定义一个代码片段，方便其它地方引入
• th:object 替换对象
• th:src 图片类地址引入
• th:text 显示文本
• th:value 属性赋值

常用函数：

• #dates 日期函数
• #lists 列表函数
• #arrays 数组函数
• #strings 字符串函数
• #numbers 数字函数
• #calendars 日历函数
• #objects 对象函数
• #bools 逻辑函数

使用Thymeleaf模板引擎

• 引入依赖

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
  </dependency>
  1
  2
  3
  4

• application.properties添加Thymeleaf配置

  #thymeleaf配置
  #模板的设置，支持HTML、XML、TEXT、JAVASCRIPT等
  spring.thymeleaf.mode=HTML5
  #编码，可不用配置
  spring.thymeleaf.encoding=UTF-8
  #内容类别，可不用配置
  spring.thymeleaf.content-type=text/html
  #开发内容为false,避免修改模板还需要重启服务器
  spring.thymeleaf.cache=false
  #配置模板路径，默认为templates，可以不用配置
  #spring.thymeleaf.prefix=classpath:/templates
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  注意：Thymeleaf模板引擎默认会读取项目资源文件夹resource下的templates目录，这个目录是用来存放HTML文件的。如果添加了Thymeleaf依赖，而没有进行任何配置，或者添加默认目录，启动应用时就会报错。

• 控制层

  • @Controller：标注此类为一个控制层类，同时让Spring Boot容器管理起来
  • @RequestMapping
  • Model对象

4、Spring Boot事务支持

Spring事务

Spring支持编程式事务管理（也称编码式事务），也支持声明式事务管理。在大多情况下，声明式事务管理比编程式事务管理更好用。Spring通过SpringAOP框架支持声明式事务管理。

数据访问的内容有很多，包括JDBC、JPA、Hibernate、分布式事务等。Spring在不同的事务管理API上定义了一个抽象层PlatformTransactionManager。

Spring并不直接管理事务，而是提供了许多内置事务管理器实现，常见的有DataSourceTransactionManager、JdoTransactionManager、JpaTransactionManager以及HibernateTransactionManager等。

Spring声明式事务

Spring配置文件中关于事务配置总是由三部分组成，分别是DataSource、TransactionManger和代理机制。

无论哪种配置方式，一般变化的只是代理机制部分，DataSource和TransactionManager这两部分只会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实现为SessionFactory，TransactionManager的实现为HibernateTransactionManager

• @Transactional：注解在类或者方法上表明该类或者方法需要事务支持，被注解的类或者方法被调用时，Spring开启一个新的事务，当方法正常运行时，Spring会提交这个事务。

注意：@Transactional注解来自org.springframework.transaction.annotation。Spring提供了@EnableTransactionManagement注解在配置类上来开启声明式事物的支持。使用@EnableTransactionManagement后，Spring容器会自动扫描注解@Transactional的方法和类。

Spring注解事务行为

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播；

例如，方法可能继续在现有事务中运行，也可能开启新事务，并在自己的事务中运行。

• 事务的传播行为可以再@Transacional的propagation属性中指定，Spring定义了7种

传播行为，具体如下。

• Spring定义了5中事务的隔离级别，在属性isolation中定义

• 还可以通过timeout属性设置事务过期时间；通过指定readOnly指定当前事务是否是只读事务；通过RollbackFor(noRollbackFor)指定哪个或这哪些事务可以引起（或不可以引起）事务回滚。

Spring Boot事务

Spring Boot开启事务很简单，只需要一个注解@Transactional就可以了，因为Spring Boot中已经默认对JPA、JDBC、Mybatis开启了事务，引入它们的依赖时，事务就默认开启。

Spring Boot用于配置事务的类为TransactionAutoConfiguration，此配置类依赖于JtaAutoConfiguration和DataSourceTransactionManagerAutoConfiguration，而DataSourceTransactionManagerAutoConfiguration开启了对声明式事务的支持，所以无需显示开启使用@EnableTransactionManager

• @Transactional可以注解在类上或者方法上。注解在类上，是此类的所有public方法都是开启事务的；如果类级别和方法级别同时使用了@Transactional注解，就使用方法级别注解覆盖类级别注解。

5、使用过滤器和监听器

过滤器Filter

• 实现Filter接口

• @WebFilter：用于将一个类声明为过滤器，该注解将会在应用部署时被容器处理，容器根据具体的数项配置将相应的类部署为过滤器；该注解常见的属性有filerName、urlPattern、value等。filerName属性用于指定过滤器的name，urlPattern属性用于指定一组过滤器的URL匹配模式。value属性等价于urlPattern，但是两者不可以同时使用。

• 在入口类中添加注解@ServletComponetScan

• @ServletComponetScan：使用该注解后，Servlet、Filter、Listener可以直接通过@WebServlet、@WebFilter、@WebListener注解自动注册，无需其他代码。

监听器Listener

• 根据监听对象分：
  • ServletContext -> application
  • HttpSession -> session
  • ServletRequest -> request
• 根据监听的事件分：
  • 监听对象的创建与销毁 -> ServletContextListener、HtppSessionListener和ServletRequestListener
  • 监听对象域中属性的增加与删除 -> ServletContextAttribute 、HttpSessionAttributeListener 和ServletRequestAttributeListener
  • 监听绑定到Session上的某个对象的状态 -> HttpSessionBindingListener 和 HttpSessionActivationListener

6、集成Redis缓存

Redis是一个基于内存的单线程高性能key-value型数据库。

Spring Boot集成Redis缓存

• 依赖

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
  1
  2
  3
  4

• application.properties配置

  ## Redis缓存配置
  ## 默认名Redis的数据库位db0
  spring.redis.database=0
  ## 服务器地址，默认为localhost
  spring.redis.host=localhost
  ## 链接端口，默认为6379
  spring.redis.port=6379
  ## redis的默认密码为空
  spring.redis.passoword=
  1
  2
  3
  4
  5
  6
  7
  8
  9

• Spring提供了模板类：RedisTemplate、StringRedisTemplate（只针对键值是字符串的数据进行操作）等。在应用启动时，Spring会初始化这两个类，通过@Resource注解注入。

• RedisTemplate和StringRedisTemplate除了提供opsForValue方法用来操作简单属性数据之外，还提供了以下数据访问方法。

  • opsForList：操作含有list的数据
  • opsForSet：操作含有set的数据
  • opsForZSet：操作含有ZSet（有序set）的数据
  • opsForHash：操作含有hash的数据

将数据存放到Redis中时，键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用 JdkSerializationRedisSerializer，而 StringRedisTemplate 默认使用的是 StringRedisSerializer

Redis缓存在Spring Boot中使用

例子：利用Listener中的初始化上下文监听器，在init方法中加载数据库中的所有用户数据，并存放在Redis缓存中。因为用户的数据变动不大，适合存放在缓存中，当应用需要用户数据时，在Redis缓存中获取，提高数据的访问速度。

redisTemplate.opsForList().leftPushAll(String,Object);
//查询缓存中所有的用户数据，若String键不存在，则会创建该键及其关联的List，之后在将参数中的List从左到右依次插入。

redisTemplate.opsForList().range（Object,int,int）;
//取链表的全部元素,其中用 0 表示第一个元素， -1 表示最后一个元素。
1
2
3
4
5

7、集成Log4j日志

Log4j有三个主要组件，分别是Loggers(记录器)、Appenders(输出源)和Layouts(布局)，这三个组件可以简单地理解为 日志类别 、日志要输出的地方 和 日志以哪种形式输出。

• Loggers ：分为 7 个级别，优先级依次为 all<debug<info<warm<error<fatal<off ，其中输出内容为不低于当前级别的日志信息。
• Appenders：可输出到控制台（Console）、文件（File）等
• Layouts：控制Log信息的输出方式，格式化输出的信息

Log4j支持XML文件配置方式和 log4j.properties 格式的配置文件

集成Log4j2

• 依赖

Spring Boot 默认使用 Logback 日志框架来记录日志，并用 Info 级别输出，所以在引入 Log4j2 之前，要排除该包的依赖，在引入 Log4j 的依赖。

具体做法：找到 pom.xml 文件中 的 spring-boot-starter-web依赖，使用 exclusion标签排除 Logback，具体如下：

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
    	<!--排查Spring Boot默认日志-->
        <exclusion>
        	<groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!--log4j2-->
<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 添加 Log4j 配置

  • 在 application.propertoes中添加配置信息

    ## Log4j配置
    logging.config=classpath:log4j2.xml
    1
    2

• 创建、配置log4j2.xml文件

  • <Console>：指定控制台输出
  • <PatternLayout>：控制日志的输出格式
  • <RollingFile>：fileName 用于定义日志的数据路径，filePattern 用于定义日志的匹配方式
  • <Filters>：日志过滤策略，<ThresholdFilter>用于指定日志信息的最低默认输出级别，默认为DEBUG

使用 Log4j 记录日志

• 将 Logger 类引入到需要的的类中

//...
Logger logger = LogManager.getLogger(this.getClass());
//...
1
2
3

8、Quartz定时器和发送Email

Quarz定时器

• 引入依赖

  <!-- quarta定时器 -->
  <dependency>
  	<groupId>org.quartz-scheduler</groupId>
      <artifactId>auartz</artifactId>
      <version>2.23</version>
  </dependency>
  1
  2
  3
  4
  5
  6

• 定时器配置文件

  • 使用XML文件配置方式

    • 在/src/main/resources目录下新建配置文件spring-mvc-xml

    <import resource="spring-auartz.xml" />
    1

    <import>：利用 import 标签导入定时器的配置文件，改标签可以根据具体业务分离配置文件

    • 创建spring-auartz.xml

  • 使用注解的方式

• 创建定时器类

  基于注解方式：

  @Component
  @Configurable
  @EnableScheduling
  public class SendMailQuartz {
      //日志对象
      private static final Loggers logger = LoggerManager.getLogger(SendMailQuzrtz.class);
      
      //每5秒执行一次
      @Scheduled(corn="* /5 * *  * * *")
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  • @Component
  • @Configurable：加上此注解的类相当于 XML 配置方式，可以被Spring Boot扫描初始化
  • EnableScheduling：通过在配置类注解@EnableScheduling来开启对计划任务的支持，然后在要执行计划任务的方法上注解@Scheduled声明这是一个计划任务
  • @Scheduled：注解为定时任务，在 cron表达式里写执行的时机

• Spring Boot 扫描配置文件

  在入口类中添加 @ImportResource注解

  @SpringBootApplicatiom
  @ServletComponentScan
  @ImportResource(locations{"classpath:spring-mvc.xml"})
  public class MySpringBoot{   ...   }
  1
  2
  3
  4

  @ImportResource：导入资源配置文件，让Spring Boot可以读取到，类似于 XML 配置文件中的<impotr>标签

Spring Boot发送Email

JDK的API：JavaMail

Spring：JavaMailSender -> Spring Boot的starter模块中已为此提供了自动化配置

• 引入依赖

  <!-- mail-->
  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-mail</artifactId>
  </dependency>
  1
  2
  3
  4
  5

• 在application.properties中添加Emial配置

  ## Mail 邮件设置
  ##邮箱主机
  spring.mail.host=smtp.qq.com
  ##用户名
  spring.mail.username=XXX@qq.com
  ##设置的密码
  spring.mail.password=*****
  ##默认编码
  spring.mail.default-encoding=UTF-8
  spring.mail.properites.mail.smtp.auth=true
  spring.mail.properties.mail.smtp.starttls.enable=true
  spring.mail.properties.mail.smtp.starttls.required=true
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 发送邮件

  @Service
  public class SendMail {
      @Autowired
      JavaMailSender mailSender;
      @Value("${spring.mail.username}")
      private String from;
      //日志
      public static final Logger logger = LogManager.getLogger(SendMail.class);
      
      public boolean send(User user){
          try{
              MimeMessage mimeMessage = this.mailSender.createMimeMessage();
              MimeMessageHelper message = new MimeMessageHelper(mimeMessage);
              //邮件发送方
              message.setFrom(from);
              //邮件主题
              message.setSubject("试发");
              //邮件接收方
              message.setTo("xxx@xxx.com");
              //邮件内容
              message.setText("Demo");
              //发送邮件
              this.mailSender.send(mimeMessage)
          }
          catch(Exception e){
              logger.error("sendError");
              return Boolean.FALSE;
          }
          return Boolean.TRUE;
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31

  @Value：可以将application.properties配置文件中的配置设置到属性中。

  JavaMailSender：邮件发送接口。Spring Boot的starter模块中已为此提供了自动化配置，只需要通过注解@Autowired注解使用

注意：发送方邮件一定要开启smtp/pop3服务

9、集成MyBatis

• 依赖

  <!-- mybatis -->
  <dependency>
  	<groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybais-spring-boot-starter</artifactId>
      <version>1.3.1</version>
  </dependency>
  1
  2
  3
  4
  5
  6

• 在application.properties中添加配置

  ### Mybatis配置
  mybatis.mapper-locations=classpath:/mapper/*Mapper.xml
  mybatis.type-aliases-package=com.example.demo.dao
  1
  2
  3

mybatis.mapper-locations：Mapper资源文件存放的路径

mybatis.type-aliases-package：Dao接口文件存放的目录

• Dao和Mapper文件开发

  • 在application.properties中声明的dao文件位置新建接口

    @Mapper
    public interface UserDao {
        User findByName(@Param("name") String name);
    }
    1
    2
    3
    4

    • @Mapper：重要注解，Mybatis根据接口定义与Mapper文件中的SQL语句动态创建接口实现
    • @Param：注解参数，在Mapper.xml配置文件中，可以采用#{}的方式对@Param注解括号内的参数进行引用

  • 在application.properties中声明的mapper.xml中添加xml文件

    • <mapper>：该标签的namespace属性用于绑定Dao接口

10、异步消息与异步调度

JMS消息介绍

JMS(Java Message Service，Java消息服务)是一组Java应用程序接口，提供消息的创建、发送、读取等一系列服务。

JMS支持两种消息发送和接收模型：

1、P2P(Point to Point)：基于队列的，消息生产者发送消息到队列，消息消费者从队列中接收消息。

特点：每个消息只有一个消费者，发送者和接收者在时间上没有依赖性。

2、Pub/Sub(Publish/Subscribe)：在一对多广播中采用

特点：有多个消费者，时间上有依赖性

Spring Boot集成ActiveMQ

MQ全称为MessageQueue(消息队列)，是一个消息的接收和转发的容器，可用于消息推送。

• 依赖

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
  </dependency>
  1
  2
  3
  4

• 在application.properties中配置

  spring.activemq.broker-url=tcp://localhost:61616
  spring.activemq.in-memory=true
  spring.activemq.pool.enabled=false
  spring.activemq.package.trust-all=true
  1
  2
  3
  4

  spring.activemq.package.trust-all ：ObjectMessage的使用机制是不安全的，ActiveMQ新版本强制Consumer端声明一份可信任的包列表，只有当ObjectMessage中的Object在可信任包内，才能被提取出来。该配置表示信任所有的包。

使用ActiveMQ

• 创建生产者

  @Service
  public class MessageProducer {
      @Resource
      private JmsMessagingTemplate jmsMesssagingTemplate;
      
      public void sendMessage(Destination destination,final String message){
          jmsMessagingTemplate.comvertAndSend(destination,message);
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9

  JmsMessagingTemplate：发消息的工具类，也可以注入JmsTemplate，JmsMessagingTemplate对JmsTemplate进行了封装。参数destination是发送到队列的，message是待发送的消息。

• 创建消费者

  @Component
  public class MessageConsumer {
      @JmsListener(destination="ay.queue")
      public void receiveQueue(String text){
          System.out.println(text);
      }
  }
  1
  2
  3
  4
  5
  6
  7

  @JmsListener：使用JmsListener配置消费者监听的队列ay.queue，其中text是接受到的消息

• 测试

  @Resource
  MessageProducer messageProducer;
  public void test{
      Destination destination = new ActiveMQQueue("ay.queue");
      messageProducer.sendMessage(destination,"hello,world");
  }
  1
  2
  3
  4
  5
  6

Spring Boot异步调用

同步调用：程序按照顺序执行

异步调用：无需等待上一步程序执行完毕即可执行；

当访问的接口较慢或者做耗时任务时，除了可以使用多线程来并行的处理认为，还可以使用Spring Boot提供的异步处理方式@Async来处理，通过此注解，可将普通的同步任务改为异步调用 任务。

• 在入口类添加注解@EnableAsync开启异步调用
• 在需要异步的方法上使用注解@Async

11、全局异常处理与Retry重试

Spring Boot全局异常使用

• 自定义错误页面

  • 新建error包，包下新建ErrorPageConfig配置类

    @Configuration
    public class ErrorPageConfig {
        @Bean 
        public EmbeddedServletContainerCustomizer containerCustomizer() {
            return new EmbeddedServletContainerCustomizer() {
                @Override
                public void customize(ConfigurableEmbeddedServletContainer container) {
                    ErrorPage error404Page = new ErrorPage(HttpStatus.NOT_FOUND,"/404.html");
                    container.addErrorPage(error404Page);
                }
            }
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    EmbeddedServletContainerCustomizer：Spring Boot的自动配置有一个特性就是能够通过代码来进行修改配置，因此只需要实现Spring Boot的接口即可。

    这里需要注册EmbeddedServletContainerCustomizer的bean，在此ErrorPageConfig类中，实现EmbeddedServletContainerCustomizer接口，实现该接口的方法，自定义错误页面。

• 全局异常类开发

  业务异常，能够被统一处理。

  • 封装自定义业务异常BussinessException继承自RuntimeException

    public class BusinessException extends RuntimeException {
        public BusinessException(){};
        public BusinessException(String message){ super(message); }
    }
    1
    2
    3
    4

  • 在error包下新建错误信息类ErrorInfo，用于封装错误信息

    public class ErrorInfo<T> {
        public static final Integer SUCCESS = 200;
        public static final Integer ERROR = 100；
            
        private Integer code;
        private String message;
        private String url;
        private T data;
        //getter and setter
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

  • 在error包下新建统一异常处理类GlobalDefaultExceptionHnadler

    @ControllerAdvice(basePackage={"com.example.demo",})
    public class GloalDefaultExceptionHandler {
        @ExceptionHandler({BusinessException.class})
        //@ExceptionHandler(value = BusinessException.class)
        @ResponseBody
        public ErrorInfo defaultErrorHandler(HttpServletRequest req,Exception e) 	 {
            ErrorInfo errorInfo = new ErrorInfo();
            errorInfo.set...
            return errorInfo;    
        }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    • @ControllerAdvice：定义统一的异常处理类，basePackage 属性用于定义扫描那些包，默认可不设置。（@RestControllerAdvice）

    • @ExceptionHandler ：用于定义函数针对的类型异常，可以传入多个需要捕获的异常类

Retry重试机制

调用一个接口时，由于某些原因造成第一次失败，再次尝试可能成功，这就是重试机制。

• 依赖

  <dependency>
  	<groupId>org.springframework.retry</groupId>
      <artifactId>spring-retry</artifactId>
  </dependency>
  <denpendency>
  	<groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
  </denpendency>
  1
  2
  3
  4
  5
  6
  7
  8

• 在入口类添加注解@EnablerRetry开启Retry重试

• 例子

  @Retryable(value={BusinessException.class},maxAttemps=5,backoff=@Backoff(delay=5000,multiplier=2))
  1

  @Retryable：value属性表示当出现哪些异常的时候触发重试，maxAttemps表示最大重试次数默认是3，delay表示重试的延迟时间，multiplier表示上一次延时时间是这一次的倍数

12、集成MongoDB数据库

特点：面向集合存储、易存储对象类型的数据、支持动态查询、文件存储格式为BSON、支持复制和故障恢复

缺点：不能建立实体关系、没有事务管理机制等

• 依赖

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-mongodb</artifactId>
  </dependency>
  1
  2
  3
  4

• application.properties中配置v

  ### mongodb配置
  ### host地址
  spring.data.mongodb.host=localhost
  ### 默认数据库端口号27017
  spring.data.mongodb.port=27017
  ### 连接数据库名 test
  spring.data.mongodb.database=test
  1
  2
  3
  4
  5
  6
  7

  • 集成MongoRepository类，MongoRepository类在spring-data-mongodb包下，类似于前面的Spring Data JPA，而MongoRepository最顶级的父类就是Reposoitory，继承后就能使用MongoRepositoy提供的增删改查方法

13、集成Spring Security

Spring Security 安全框架提供了认证和授权功能、加密解密、统一登录等支持。

• 依赖

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
      <version>1.5.9.RELEASE</version>
  </dependency>
  1
  2
  3
  4
  5

• security配置类

  @Configuration
  @EnableWebSecurity
  public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
      @Override
      protected void configure(HttpSecurity http) throws Exception {
          //路由策略和访问权限的简单配置
          http.formLogin()     //启用默认登陆页面
              .failureUrl("/login?error")  //登录失败返回URL:/login？error
              .defaultSuccessUrl("/ayUser/test") //登陆成功跳转URL,这里跳转到用户首页
              .permitAll();        //登录页面全部权限可访问
          super.configure(http);
      }
      
      /**
       * 配置内存用户
       */
      @Autowired
      public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
          auth
              .inMemoryAuthentication()
              .withUser("test").password("123").roles("ADMIN")
              .and()
              .withUser("demo").password("123").roles("USER");
              
      }
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26

  • @EnableWebSecurity：开启 Security 安全框架
  • configure 方法：WebSecurityConfig继承WebSecurityConfigureAdapter类需要重写configure方法，通过formLogin方法配置启用默认登录页面
  • configureGlobal方法：参数AuthenticationManagerBuilder类的方法inMemoryAuthentication可添加内存中的用户，并可给用户指定角色权限。

14、Spring Boot 应用监控

Spring Boot提供了spring-boot-starter-actuator模块，主要用于管理和监控应用

• 依赖

  <dependency>
  	<groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
      <version>1.5.10.RELEASE</version>
  </dependency>
  1
  2
  3
  4
  5

• application.properties中配置

  ### 应用监控配置
  # 指定访问这些监控方法的端口
  # management.port
  # 指定地址，比如只能通过本机监控，可以设置
  # management.address=127.0.0.1
  # 敏感信息访问权限
  # endpoint.bean.sensitive=false
  # 设置关闭安全限制
  management.security.enabled=false
  1
  2
  3
  4
  5
  6
  7
  8
  9

15、集成Dubbo和Zookeeper

Zookpper

Zookeeper是一个开源的分布式应用程序协调服务，提供的功能包括命名服务、配置管理、集群管理、分布式锁等。

1、命名服务：在分布式环境下，经常需要对应用 / 服务进行统一命名，便于识别不同服务，类似于DNS。Zookeeper通过名称来获取资源或服务的地址、提供者等信息。

2、配置管理：分布式系统中都有大量服务器，Zookeeper提供了一种集中管理配置的方法，在这个集中的地方修改了配置，所有对这个配置感兴趣的都会获得变更。

3、集群管理：包括两点：是否有机器退出和加入、选取Master

4、分布式锁：Zookeeper的一致性文件系统使得锁的问题变得容易。锁服务可以分为两类：一类是保持独占，另一类是时序控制。

Spring Boot集成Dubbo

Dubbo是一款Java服务平台框架以及SOA治理方案。其功能主要包括：高性能NIO通信及多协议集成、服务动态寻址与路由、软负载均衡与容错、依赖分析与降级等。

Registry是服务注册与发现的注册中心，Provider是暴露服务的服务提供方，Consumer是调用远程服务的服务消费方，Monitor是统计服务的调用次数和调用时间的监控中心，Container是服务运行容器。

Duubo简单的调用关系如下：

1、服务容器Container负责启动、加载、运行服务提供者Provider

2、服务提供者Provider在启动时，向注册中心Registry注册自己的服务

3、服务消费者Consumer在启动时，向注册中心Registry订阅自己所需的服务

4、注册中心Register返回服务提供者地址列表给消费者Provider，如果有变更，注册中心Registry将基于长连接推送，变更数据给消费者Consumer

5、服务调用者Consumer从提供者地址列表中基于软负载均衡算法选一台提供者进行调用，如果调用失败，就在线另一台进行调用

6、服务消费者Consumer和提供者Provider在内存中累计调用次数和调用时间，按时每分钟发送一次统计数据到监控中心Monitor

16、Spring Boot原理解析

@SpringApplication原理

@SpringAplication开启了Spring的组件扫描和Spring Boot自动配置功能。实际上是一个复合注解，包含了@SpringBootConfigutation、EnableAutoConfigutarion、@ComponentScan

• @SptingBootConfiguration注解：标明该类使用Spring基于Java注解，Spring Boot推荐使用基于Java注解，而不是XML的配置。@SpringBootConfiguration是对@Configuration进行了包装。
• @EnableAutoConfiguration：该注解可以自动开启自动配置的功能
• @ComponentScan：启动组件扫描，开发的组件过bean定义能被发现并注入Spring应用程序上下文。比如@Controller、@Service、@Component注解等，都可以被扫描到