Spring

发布日期: 2021-05-06

文章字数: 5.3k

阅读时长: 24 分

阅读次数:

目录

Springboot简介

Springboot整合依赖汇总

发布打包

Springboot简介

Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

Spring Boot的主要优点：

为所有Spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化Web项目
没有冗余代码生成和XML配置的要求

概念

（1）SpringBoot的宗旨并非要重写Spring或是替代Spring, 而是希望通过设计大量的自动化配置等方式来简化Spring原有样板化的配置，使得开发者可以快速构建应用。

（2）Spring Boot还通过一系列StaiterPOMs的定义，让我们整合各项功能的时候， 不需要在 Maven的pom.xml中维护那些错综复杂的依赖关系，而是通过类似模块化的Starter模块定义来引用，使得依赖管理工作变得更为简单。

（3）Spring Boot除了可以很好融入Docker之外，其自身就支持嵌入式的 Tomcat、 Jetty 等容器。所以，通过Spring Boot 构建的应用不再需要安装Tomcat, 将应用打包成war, 再部署到Tomcat 这样复杂的构建与部署动作，只需将SpringBoot应用打成jar包，并通过java -jar命令直接运行就能启动一个标准化的Web应用。

配置

Starter POMS

Spring Boot的StarterPOMs采用spring-boot-starter-*的命名方式，＊代表一个特别的应用功能模块，比如web、test。Spring Boot工程本身的结构非常简单，大量的学习要点还是将来在对这些StarterPOMs的使用之上。

配置文件

关于SpringBoot应用的配置内容都可以集中在该文件中，根据我们引入的不同Starter模块，可以在这里定义容器端口号、数据库连接信息、日志级别等各种配置信息。

文件创建

（1）默认配置文件位置为 src/main/resources/application.properties。

（2）使用application.yml文件

参数

（1）自定义参数

除了可以在 Spring Boot 的配置文件中设置各个 Starter 模块中预定义的配置属性，也可

以在配置文件中定义一些我们需要的自定义属性。比如在 application.properties 中添加：

book.name=SpringCloudinAction
book.author=ZhaiYongchao

然后，在应用中可以通过@Value 注解来加载这些自定义的参数，比如：

@Component
public class Book {
  @Value("${book.name}")
  private String name;
  @Value("${book.author}")
  private String author;
  ／／省略getter和setter
}

@Value 注解加载属性值的时候可以支持两种表达式来进行配置，如下所示。

• 一种是上面介绍的 PlaceHolder（占位符）方式，格式为＄｛．．．｝，大括号内为 PlaceHolder。

• 另一种是使用SpEL 表达式 (Spring Expression Language), 格式为＃｛．．．｝，大括号内为 SpEL 表达式

（2）参数引用

book.name=SpringCloud
book.author=ZhaiYongchao
book.desc=${book.author} is writing《${book.name}》

book.desc 参数引用了上文中定义的book.name和book.author 属性，最后该属性的值就是ZhaiYongchao is writing《SpringCloud》

（3）使用命令行配置参数

在用命令行方式启动Spring Boot 应用时，连续的两个减号－－就是对application.properties 中的属性值进行赋值的标识。所以， java -jar xxx.jar–server.port=8888命令，等价于在 application.properties 中添加属性server.port= 8888。

多环境配置

在 Spring Boot 中，多环境配置的文件名需要满足 application-{profile}.properties的格式，其中{profile}对应你的环境标识，如下所示。

• application-dev.properties: 开发环境。

• application-test.properties: 测试环境。

• application-prod.properties: 生产环境。

至于具体哪个配置文件会被加载，需要在 application.properties 文件中通过spring.profiles.active 属性来设置，其值对应配置文件中的{profile}值。如spring.profiles.active= test就会加载application.properties配置文件内容。

指向启动java -jar xxx.jar –spring.profiles.active=xxx，分别启动多个配置文件。

加载顺序

（1）在命令行中传入的参数。

（2）SPRING_APPLICATION_JSON中的属性。 SPRING_APPLICATION_JSON是以

JSON格式配置在系统环境变量中的内容。

（3）java:comp/env中的JNDI 属性。

（4）Java的系统属性，可以通过System.getProperties()获得的内容。

（5）操作系统的环境变量。

（6）通过random.*配置的随机属性

（7）位于当前应用 jar 包之外，针对不同{profile}环境的配置文件内容，例如

application-{profile}.properties或是YAML定义的配置文件。

（8）位于当前应用 jar 包之内，针对不同{profile}环境的配置文件内容，例如

application-{profile}.properties或是YAML定义的配置文件。

（9）位于当前应用jar包之外的application.properties和YAML配置内容。

（10）位于当前应用jar包之内的application.properties和YAML配置内容。

（11）在@Configuration注解修改的类中，通过@PropertySource注解定义的属性。

（12）应用默认属性，使用SpringApplication.setDefaultProperties 定义的内容。

监控管理

spring-boot-starter-actuator

引入该模块能够自动为 Spring Boot 构建的应用提供一系列用于监控的端点。同时， SpringCloud 在实现各个微服务组件的时候，进一步为该模块做了不少扩展，比如，为原生端点增加了更多的指标和度量信息（比如在整合 Eureka 的时候会为/health 端点增加相关的信息），并且根据不同的组件还提供了更多有空的端点（比如，为 API 网关组件 Zuul 提供了 /routes 端点来返回路由信息）。

依赖

<dependency>
  <groupid> org.springframework.boot</groupid>
  <artifactid>spring-boot-starter-actuator</artifactid>
</dependency>

原生端点

添加上述依赖后，启动程序，会创建如图所示的端点。根据端点的作用，可以将原生端点分为以下三大类。

（1）应用配置类

获取应用程序中加载的应用配置、环境变量、自动化配置报告等与Spring Boot应用密切相关的配置类信息。

（2）度最指标类

获取应用程序运行过程中用于监控的度量指标，比如内存信息、线程池信息、 HTTP请求统计等。

（3）操作控制类

提供了对应用的关闭等操作类功能。

日志

Springboot默认集成了logback日志，可以在resource文件夹下配置logback.xml文件，即可使用

<?xml version="1.0" encoding="UTF-8"?>
<configuration>    
	<!-- 项目名称 -->
	<property name="projectname" value="XXX" />    
	<!-- 日志存放路径 -->
	<property name="log.path" value="./logs/" />    
	<!-- 日志输出格式 -->
	<property name="log.pattern"
		value="%d{yyy-MM-dd HH:mm:ss.SSS} [%X{X-B3-TraceId:-},%X{X-B3-SpanId:-}] [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />   
	<!-- 控制台输出 -->
	<appender name="console"
		class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
	</appender>      
	<!-- 系统日志输出 -->
	<appender name="file_info"
		class="ch.qos.logback.core.rolling.RollingFileAppender">
		<file>${log.path}/${projectname}-info.log</file>        
		<!-- 循环政策：基于时间创建日志文件 -->
		<rollingPolicy
			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">            
			<!-- 日志文件名格式 -->
			<fileNamePattern>${log.path}/${projectname}-info.%d{yyyy-MM-dd}.log
			</fileNamePattern>         
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">            
			<!-- 过滤的级别 -->
			<level>INFO</level>            
			<!-- 匹配时的操作：接收（记录） -->
			<onMatch>ACCEPT</onMatch>            
			<!-- 不匹配时的操作：拒绝（不记录） -->
			<onMismatch>DENY</onMismatch>
		</filter>
	</appender>
	<appender name="file_error"
		class="ch.qos.logback.core.rolling.RollingFileAppender">
		<file>${log.path}/${projectname}-error.log</file>        
		<!-- 循环政策：基于时间创建日志文件 -->
		<rollingPolicy
			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">            
			<!-- 日志文件名格式 -->
			<fileNamePattern>${log.path}/${projectname}-error.%d{yyyy-MM-dd}.log
			</fileNamePattern>         
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">           
			 <!-- 过滤的级别 -->
			<level>ERROR</level>         
			<!-- 匹配时的操作：接收（记录） -->
			<onMatch>ACCEPT</onMatch>         
			<!-- 不匹配时的操作：拒绝（不记录） -->
			<onMismatch>DENY</onMismatch>
		</filter>
	</appender>      
	<!-- 系统模块日志级别控制 -->
	<logger name="com.loop" level="info" />   
	<!-- Spring日志级别控制 -->
	<logger name="org.springframework" level="warn" />
	<root level="info">
		<appender-ref ref="console" />
	</root>      
	<!--系统操作日志 -->
	<root level="info">
		<appender-ref ref="file_info" />
		<appender-ref ref="file_error" />
	</root>
</configuration>

Springboot整合依赖汇总

Spring Web基础

Web基础依赖

<parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.5.2.RELEASE</version>
     <relativePath /> <!-- lookup parent from repository -->
 </parent>
<dependencies>
   <!-- 集成web -->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>
 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <version>2.4.2</version>
             <configuration>
                 <skipTests>true</skipTests>
             </configuration>
         </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-clean-plugin</artifactId>
             <version>3.0.0</version>
             <configuration>
                 <skipTests>true</skipTests>
             </configuration>
         </plugin>
     </plugins> 
</build>

spring-boot-starter-web会自动引入spring-webmvc，spring-boot-starter-validation，spring-boot-starter，spring-boot-starter-json，spring-boot-starter-tomcat 这5个基础依赖

配置和启动

（1）spring-boot-starter-web添加了Tomcat和Spring MVC
（2）Springboot的几种启动方式：

@EnableAutoConfiguration，auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

@RestController
@EnableAutoConfiguration
public class HelloController {
     @RequestMapping("/hello")
     public String index() {
          return "Hello World";
     }
     public static void main(String[] args) {
         SpringApplication.run(HelloController.class, args);
     }
 }

@ComponentScan(basePackages = "com.itmayiedu.controller") 控制器扫包

@ComponentScan(basePackages = "com.itmayiedu.controller")
@EnableAutoConfiguration
public class App {
    public static void main(String[] args) {
         SpringApplication.run(App.class, args);
    }
}

（推荐) @SpringBootApplication注解
可以简化部分配置，但mybatis的mapper扫包和springcloud的eureka启动等不能少。

@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages="com.qian.mapper")
public class MemberApp {
     public static void main(String[] args) {
        SpringApplication.run(MemberApp.class, args);
     }
 }

（3）yml配置文件

server:
   port: 8080
   servlet: # 注意这里配置工程上下文路径，要在server.servlet下！！
   	context-path: /project

页面渲染

静态资源访问

在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。
Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：

/static
/public
/resources
/META-INF/resources

举例：我们可以在src/main/resources/目录下创建static文件夹，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/D.jpg。如能显示图片，配置成功。

Thymeleaf

依赖

在Spring Boot中使用Thymeleaf只需在pom中加入Thymeleaf的starter即可：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

在Spring Boot 1.5.9.RELEASE版本中，默认的Thymeleaf版本为2.1.6.RELEASE版本，这里推荐使用3.0以上版本。在pom中将Thymeleaf的版本修改为3.0.2.RELEASE：

<properties>
    <thymeleaf.version>3.0.2.RELEASE</thymeleaf.version>
    <thymeleaf-layout-dialect.version>2.0.1</thymeleaf-layout-dialect.version>
</properties>

在Spring Boot中，默认的html页面地址为src/main/resources/templates，默认的静态资源地址为src/main/resources/static。

Thymeleaf默认配置

在Spring Boot配置文件中可对Thymeleaf的默认配置进行修改：

#开启模板缓存（默认值：true）
spring.thymeleaf.cache=true 
#Check that the template exists before rendering it.
spring.thymeleaf.check-template=true 
#检查模板位置是否正确（默认值:true）
spring.thymeleaf.check-template-location=true
#Content-Type的值（默认值：text/html）
spring.thymeleaf.content-type=text/html
#开启MVC Thymeleaf视图解析（默认值：true）
spring.thymeleaf.enabled=true
#模板编码
spring.thymeleaf.encoding=UTF-8
#要被排除在解析之外的视图名称列表，用逗号分隔
spring.thymeleaf.excluded-view-names=
#要运用于模板之上的模板模式。另见StandardTemplate-ModeHandlers(默认值：HTML5)
spring.thymeleaf.mode=HTML5
#在构建URL时添加到视图名称前的前缀（默认值：classpath:/templates/）
spring.thymeleaf.prefix=classpath:/templates/
#在构建URL时添加到视图名称后的后缀（默认值：.html）
spring.thymeleaf.suffix=.html
#Thymeleaf模板解析器在解析器链中的顺序。默认情况下，它排第一位。顺序从1开始，只有在定义了额外的TemplateResolver Bean时才需要设置这个属性。
spring.thymeleaf.template-resolver-order=
#可解析的视图名称列表，用逗号分隔
spring.thymeleaf.view-names=

一般开发中将spring.thymeleaf.cache设置为false，其他保持默认值即可。

简化的yml版本：

spring:
   thymeleaf: 
      cache: false
      encoding: UTF-8
      mode: HTML5
      prefix: classpath:/templates/
      suffix: .html

简单示例

编写一个简单的Controller：

@Controller
public class IndexController {
	
    @RequestMapping("/account")
    public String index(Model m) {
        List<Account> list = new ArrayList<Account>();
        list.add(new Account("KangKang", "康康", "e10adc3949ba59abbe56e", "超级管理员", "17777777777"));
        list.add(new Account("Mike", "麦克", "e10adc3949ba59abbe56e", "管理员", "13444444444"));
        list.add(new Account("Jane","简","e10adc3949ba59abbe56e","运维人员","18666666666"));
        list.add(new Account("Maria", "玛利亚", "e10adc3949ba59abbe56e", "清算人员", "19999999999"));
        m.addAttribute("accountList",list);
        return "account";
    }
}

编写account.html页面：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>account</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <link rel="stylesheet" th:href="@{/css/style.css}" type="text/css">
</head>
<body>
    <table>
        <tr>
            <th>no</th>
            <th>account</th>
            <th>name</th>
            <th>password</th>
            <th>accountType</th>
            <th>tel</th>
        </tr>
        <tr th:each="list,stat : ${accountList}">
            <td th:text="${stat.count}"></td>
            <td th:text="${list.account}"></td>
            <td th:text="${list.name}"></td>
            <td th:text="${list.password}"></td>
            <td th:text="${list.accountType}"></td>
            <td th:text="${list.tel}"></td>
        </tr>
    </table>
</body>
</html>

最终项目目录如下所示：

启动项目，访问http://localhost:8080/web/account：

Freemarker

模板引擎

模板的诞生是为了将显示与数据分离，模板技术多种多样，但其本质是将模板文件和数据通过模板引擎生成最终的HTML代码。使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，用于网站的模板引擎就会生成一个标准的HTML文档在原有的HTML页面中来填充数据。最终达到渲染页面的目的。

模板技术并不是什么神秘技术，干的是拼接字符串的体力活。模板引擎就是利用正则表达式识别模板标识，并利用数据替换其中的标识符。比如：Hello, <%= name%>

数据是{name: ‘木的树’}，那么通过模板引擎解析后，我们希望得到Hello, 木的树。模板的前半部分是普通字符串，后半部分是模板标识，我们需要将其中的标识符替换为表达式。

Freemarker

（1）maven依赖

使用jar工程即可！

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

（2）yml配置

spring:
   freemarker:
       allow-request-override : false
       cache : true
       check-template-location : true
       charset : UTF-8
       content-type : text/html
       expose-request-attributes : false
       expose-session-attributes : false
       expose-spring-macro-helpers : false
       suffix : .ftl
       template-loader-path : classpath:/templates/

其实上述suffix可以该为.html即可支持html格式文件，测试有效！

（3）启动

@RequestMapping("/index")
public String index(Map<String, Object> map) {
     map.put("name","美丽的天使...");
     return "index";
 }

Map或者modelMap和request转发是一样的

JSP

maven依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
 </dependency>
 <dependency>
     <groupId>org.apache.tomcat.embed</groupId>
     <artifactId>tomcat-embed-jasper</artifactId>
 </dependency>

maven中使用war类型工程,这点区别于freemarker！

yml配置

spring: 
     mvc: 
         view: 
             prefix: /WEB-INF/jsp/
             suffix: .jsp

启动

@Controller 
public class IndexController {
    @RequestMapping("/index")
    public String index() {
        return "index";
    }
}

数据库访问

JdbcTemplate

maven依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.21</version>
 </dependency>

yml配置

spring:
   datasource :
       url : jdbc:mysql://localhost:3306/test
       username : root
       password : root
       driver-class-name : com.mysql.jdbc.Driver

调用

@Service
public class UserServiceImpl implements UserService {
     @Autowired
     private JdbcTemplate jdbcTemplate;
     public void createUser(String name, Integer age) {
         System.*out*.println("ssss");
         jdbcTemplate.update("insert into users values(null,?,?);", name, age);
     }
 }

Mybatis

maven依赖

<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>1.1.1</version>
 </dependency>
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.46</version>
 </dependency>

yml配置

spring:
   datasource :
       url : jdbc:mysql://localhost:3306/test
       username : root
       password : root
       driver-class-name : com.mysql.jdbc.Driver

调用

（1）定义mapper接口

public interface UserMapper {
     @Select("SELECT * FROM USERS WHERE NAME = #{name}")
     User findByName(@Param("name") String name);
     @Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
     int insert(@Param("name") String name, @Param("age") Integer age);
}

（2）@MapperScan(basePackages = “com.mapper”)扫包

@ComponentScan(basePackages = "com.qian")
@MapperScan(basePackages = "com.qian.mapper")
@SpringBootApplication
public class App {
     public static void main(String[] args) {
     SpringApplication.*run*(App.class, args);
    }
 }

这里除了使用@MapperScan扫描mapper层，也可以直接在mapper接口上使用@Mapper注解

@Mapper
public interface UserMapper {
...
}

Springjpa

maven依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.21</version>
</dependency>

yml配置

spring:
   datasource :
       url : jdbc:mysql://localhost:3306/test
       username : root
       password : root
       driver-class-name : com.mysql.jdbc.Driver

调用和启动

（1）创建实体类

@Entity(name = "users")
public class User {
     @Id
     @GeneratedValue
     private Integer id;
     @Column
     private String name;
     @Column
     private Integer age;
       // ..get/set方法
}

（2）创建Dao接口

public interface UserDao extends JpaRepository<User, Integer> {
}

（3）@EnableJpaRepositories(basePackages = “com.qian.dao”)启动

@ComponentScan(basePackages = { "com.qian" })
@EnableJpaRepositories(basePackages = "com.qian.dao")
@EnableAutoConfiguration
@EntityScan(basePackages = "com.itmayiedu.entity")
public class App {
     public static void main(String[] args) {
         SpringApplication.*run*(App.class, args);
    }
}

Lombok

maven依赖

<!--Lombok -->
<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.18.6</version>
</dependency>
<dependency>
     <groupId>net.logstash.logback</groupId>
     <artifactId>logstash-logback-encoder</artifactId>
     <version>4.9</version>
</dependency>

lombok配置文件

文件名：logback.xml

位置：放到resource文件夹下

<?xml version="1.0" encoding="UTF-8"?>
<configuration>    
	<!-- 项目名称 -->
	<property name="projectname" value="XXX" />    
	<!-- 日志存放路径 -->
	<property name="log.path" value="./logs/" />    
	<!-- 日志输出格式 -->
	<property name="log.pattern"
		value="%d{yyy-MM-dd HH:mm:ss.SSS} [%X{X-B3-TraceId:-},%X{X-B3-SpanId:-}] [%thread] %-5level %logger{20} - [%method,%line] - %msg%n" />   
	<!-- 控制台输出 -->
	<appender name="console"
		class="ch.qos.logback.core.ConsoleAppender">
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
	</appender>      
	<!-- 系统日志输出 -->
	<appender name="file_info"
		class="ch.qos.logback.core.rolling.RollingFileAppender">
		<file>${log.path}/${projectname}-info.log</file>        
		<!-- 循环政策：基于时间创建日志文件 -->
		<rollingPolicy
			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">            
			<!-- 日志文件名格式 -->
			<fileNamePattern>${log.path}/${projectname}-info.%d{yyyy-MM-dd}.log
			</fileNamePattern>         
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">            
			<!-- 过滤的级别 -->
			<level>INFO</level>            
			<!-- 匹配时的操作：接收（记录） -->
			<onMatch>ACCEPT</onMatch>            
			<!-- 不匹配时的操作：拒绝（不记录） -->
			<onMismatch>DENY</onMismatch>
		</filter>
	</appender>
	<appender name="file_error"
		class="ch.qos.logback.core.rolling.RollingFileAppender">
		<file>${log.path}/${projectname}-error.log</file>        
		<!-- 循环政策：基于时间创建日志文件 -->
		<rollingPolicy
			class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">            
			<!-- 日志文件名格式 -->
			<fileNamePattern>${log.path}/${projectname}-error.%d{yyyy-MM-dd}.log
			</fileNamePattern>         
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<filter class="ch.qos.logback.classic.filter.LevelFilter">           
			 <!-- 过滤的级别 -->
			<level>ERROR</level>         
			<!-- 匹配时的操作：接收（记录） -->
			<onMatch>ACCEPT</onMatch>         
			<!-- 不匹配时的操作：拒绝（不记录） -->
			<onMismatch>DENY</onMismatch>
		</filter>
	</appender>      
	<!-- 系统模块日志级别控制 -->
	<logger name="com.loop" level="info" />   
	<!-- Spring日志级别控制 -->
	<logger name="org.springframework" level="warn" />
	<root level="info">
		<appender-ref ref="console" />
	</root>      
	<!--系统操作日志 -->
	<root level="info">
		<appender-ref ref="file_info" />
		<appender-ref ref="file_error" />
	</root>
</configuration>

安装lombok插件

（1）下载lombok.jar包https://projectlombok.org/download.html

（2）运行Lombok.jar: java -jar D:\software\lombok.jar。D:\software\lombok.jar这是windows下lombok.jar所在的位置。数秒后将弹出一框，以确认eclipse的安装路径。

（3）确认完eclipse的安装路径后，点击install/update按钮，即可安装完成

（4）安装完成之后，请确认eclipse安装路径下是否多了一个lombok.jar包，并且其配置文件eclipse.ini中是否添加了如下内容:

-javaagent:lombok.jar
-Xbootclasspath/a:lombok.jar

那么恭喜你已经安装成功，否则将缺少的部分添加到相应的位置即可，重启eclipse或myeclipse。

common-lang3工具包

Apache Commons Lang, a package of Java utility classes for the classes that are in java.lang’s hierarchy, or are considered to be so standard as to justify existence in java.lang.

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

说明

关于ActiveMQ、Redis、Zookeeper、Dubbo、Spring Cloud 的相关依赖，在其各自专题介绍。

发布打包

（1）在pom文件下，使用mvn clean 和 man install 打包

（2）使用 “java –jar 包名” 运行应用

注意事项
如果报错没有主清单,在pom文件中新增

<build>
     <plugins>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
                 <source>1.8</source>
                 <target>1.8</target>
             </configuration>
         </plugin>
         <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
                 <configuration>
                     <maimClass>com.qian.app.App</maimClass>
                 </configuration>
                 <executions>
                     <execution>
                         <goals>
                             <goal>repackage</goal>
                         </goals>
                     </execution>
                 </executions> 
         </plugin>
     </plugins>
</build>

小小千千

https://jason-qianhao.github.io/2021/05/06/springboot-he-chang-jian-kuang-jia-zheng-he/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源小小千千 !

Springboot Spring

JavaScript知识汇总

2021-06-17 前端

前端 JavaScipt

《大型网站技术架构-核心原理与案例分析》学习笔记

2021-04-23 架构

架构

Springboot和常见框架整合

Springboot简介

概念

配置

Starter POMS

配置文件

文件创建

参数

多环境配置

加载顺序

监控管理

spring-boot-starter-actuator

依赖

原生端点

日志

Springboot整合依赖汇总

Spring Web基础

Web基础依赖

配置和启动

页面渲染

静态资源访问

Thymeleaf

依赖

Thymeleaf默认配置

简单示例

Freemarker

模板引擎

Freemarker

JSP

maven依赖

yml配置

启动

数据库访问

JdbcTemplate

maven依赖

yml配置

调用

Mybatis

maven依赖

yml配置

调用

Springjpa

maven依赖

yml配置

调用和启动

Lombok

maven依赖

lombok配置文件

安装lombok插件

common-lang3工具包

说明

发布打包

你的赏识是我前进的动力