springboot常用开发实现方法

最新推荐文章于 2024-03-24 22:39:47 发布

qxdzy

最新推荐文章于 2024-03-24 22:39:47 发布

阅读量501

点赞数

分类专栏： springboot开发技术文章标签： springboot常用技术简介

本文链接：https://blog.csdn.net/qxdzy/article/details/103460300

版权

springboot开发技术专栏收录该内容

1 篇文章 0 订阅

订阅专栏

springBoot微服务开发解决方案

一 SpringBoot介绍

springboot简介
1. 大家都知道以前的分布式开发项目，但是在配置这一方面上来看，很繁琐，而且很难记，现在开发的快速开发框架SpringBoot解决了这个地方。
系统要求
1. java1.8 以上的版本
2. 简化xml配置采用注解的方式
3. 默认内部继承SpringMVC框架
现在都知道SpringBoot和SpringCloud框架区别是
1. 现在都说SpringBoot是微服务框架，但是不是这个样子的，SpringBoot只是一个内部集成tomcat服务器，的一个快速开发框架
2. SpringCloud是一款微服务解决框架，是基于SpringBoot开发的一款框架，内部是一套完整的微服务解决框架。

二快速入门

创建maven工程，但使用jsp的时候要将打包为war文件。
引入pom文件的依赖,这个是项目运行的依赖

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

spring-boot-starter-parent作用:dependency management,也就是说依赖管理，引入以后在申明其它dependency的时候就不需要version了，后面可以看到。
spring-boot-starter-web:springweb 核心组件
1. spring-boot-maven-plugin作用：如果我们要直接Main启动spring，那么以下plugin必须要添加，否则是无法启动的。如果使用maven 的spring-boot:run的话是不需要此配置的。（我在测试的时候，如果不配置下面的plugin也是直接在Main中运行的。）
编写第一个程序

@RestController //这个是springmvc中的controller注解默认注入到spring容器中，rest是将返回结果为json格式。

@EnableAutoConfiguration//自动配置相应的配置。
public class HelloController {
	@RequestMapping("/hello")
	public String index() {
		return "Hello World";
	}	
public static void main(String[] args) {
		SpringApplication.run(HelloController.class, args);
    //SpringApplication 启动类。
	}
}

启动方式为3种
1. 在Controller中加入main函数，利用SpringApplication类来启动类，但是这样只能启动一个controller服务。
2. 标注扫描包的范围用
  @ComponentScan(basePackages=“com.itmayiedu.controller”)
  在mian函数中用启动类来启动所有的Controller服务。
3. 在所有的包的类前面的包中添加main函数和启动类，这样自动扫描所有的包和类。
  三 web开发
4. 静态资源访问：src/main/resources/static/下面加上资源。
  访问路径为http://localhost:8080/img/D.jpg
5. 渲染Web页面
  最好使用模板引擎，最好不要使用jsp要不然会很麻烦的，但是想要使用的话，你那么在后面会讲。
  模板引擎包括：
  · Thymeleaf
  · FreeMarker ：我喜欢用这个。
  · Velocity
  · Groovy
  · Mustache
6. 使用FreeMarker模板引擎渲染页面
  1. 引入依赖

 <!-- 引入freeMarker的依赖包. -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-freemarker</artifactId>
 </dependency>

  2. 后台代码
     在resource目录下建立template目录，并且写文件后缀为ftl文件名。
     后台代码如下：

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

     前台代码：

 <!DOCTYPE html>
 <html>
 <head lang="en">
 <meta charset="UTF-8" />
 <title></title>
 </head>
 <body>
 	  ${name}
 </body> 
 </html>

     其他用法：
     判断：<#if sex=="1"> <#elseif>
     循环： <#list userlist as user>${user}</#list>
  3. 配置FREEMARKER文件：

 ########################################################
 ###FREEMARKER (FreeMarkerAutoConfiguration)
 ########################################################
 spring.freemarker.allow-request-override=false
 spring.freemarker.cache=true
 spring.freemarker.check-template-location=true
 spring.freemarker.charset=UTF-8
 spring.freemarker.content-type=text/html
 spring.freemarker.expose-request-attributes=false
 spring.freemarker.expose-session-attributes=false
 spring.freemarker.expose-spring-macro-helpers=false
 #spring.freemarker.prefix=
 #spring.freemarker.request-context-attribute=
 #spring.freemarker.settings.*=
 spring.freemarker.suffix=.ftl
 spring.freemarker.template-loader-path=classpath:/templates/
 #comma-separated list
 #spring.freemarker.view-names= # whitelist of view names that can be resolved

  4. 使用jsp渲染页面
     1. 引入依赖：

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<!-- SpringBoot web 核心组件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
	<!-- SpringBoot 外部tomcat支持 -->	
	<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
	</dependencies>

     2. 配置文件application.properties加入前缀后缀：

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

     3. 后台代码：

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

  5. 全局捕获异常
     1. @ExceptionHandler表示拦截异常
        1. @ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局异常处理的切面类
        2. @ControllerAdvice 可以指定扫描范围
        3. @ControllerAdvice 约定了几种可行的返回值，如果是直接返回 model 类的话，需要使用 
     2. @ResponseBody 进行 json 转换
        1. 返回 String，表示跳到某个 view
        2. 返回 modelAndView
        3. 返回 model + @ResponseBody
     3. 代码如下：

@ControllerAdvice
public class GlobalExceptionHandler {
	@ExceptionHandler(RuntimeException.class)
	@ResponseBody
	public Map<String, Object> exceptionHandler() {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("errorCode", "101");
		map.put("errorMsg", "系統错误!");
		return map;
	}
}

四数据访问

SpringBoot整合jdbctemplate
1. 引入依赖代码：

 <parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
 		<version>2.0.0.RELEASE</version>
 	</parent>
 	<dependencies>
 		<!-- jdbcTemplate 依赖 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-jdbc</artifactId>
 		</dependency>
 		<!-- mysql 依赖 -->
 		<dependency>
 			<groupId>mysql</groupId>
 			<artifactId>mysql-connector-java</artifactId>
 		</dependency>
 		<!-- 测试 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
 		<!-- springboot-web组件 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
 	</dependencies>

  2. application.properties配置文件：

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

  3. 测试UserService类代码：

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

  4. 启动代码：

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

SpringBoot整合mybatis
1. pom文件引入依赖

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<!-- 测试 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.mybatis.spring.boot</groupId>
		<artifactId>mybatis-spring-boot-starter</artifactId>
		<version>1.1.1</version>
	</dependency>
	<!-- mysql 依赖 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<!-- springboot-web组件 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

  2. 配置application.properties文件

         spring.datasource.url=jdbc:mysql://localhost:3306/test
         spring.datasource.username=root
         spring.datasource.password=root
         spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  3. 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);
         }

  4. 启动代码：（注意要扫描包）

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

     @SpringBootApplication包括扫描包和自动配置，但是在包多的时候效率就不是那么直接写配置扫描包路径的时候效率高。

mybatis整合分页组件
1. pageHelper：是一款开源的分页插件（物理分页）
2. maven依赖：

 <parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
 		<version>2.0.0.RELEASE</version>
 	</parent>
 	<dependencies>
 		<dependency>
 			<groupId>org.projectlombok</groupId>
 			<artifactId>lombok</artifactId>
 		</dependency>
 
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter</artifactId>
 		</dependency>
 		<!-- 测试 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.mybatis.spring.boot</groupId>
 			<artifactId>mybatis-spring-boot-starter</artifactId>
 			<version>1.1.1</version>
 		</dependency>
 		<!-- mysql 依赖 -->
 		<dependency>
 			<groupId>mysql</groupId>
 			<artifactId>mysql-connector-java</artifactId>
 		</dependency>
 		<!-- springboot-web组件 -->
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
 		<!-- springboot 整合 pagehelper -->
 		<dependency>
 			<groupId>com.github.pagehelper</groupId>
 			<artifactId>pagehelper-spring-boot-starter</artifactId>
 			<version>1.2.5</version>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
 			<artifactId>commons-lang3</artifactId>
 			<version>3.7</version>
 		</dependency>
 	</dependencies>

  3. 配置application.properties文件：

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

 logging.level.com.example.demo.dao=DEBUG
 pagehelper.helperDialect=mysql
 pagehelper.reasonable=true
 pagehelper.supportMethodsArguments=true
 pagehelper.params=count=countSql
 pagehelper.page-size-zero=true

  4. 实体类Entity中的User实体类

 @Data
 public class User {
 	private Integer id;
 	private String name;
 	private Integer age;
 }

  5. mapper代码：

 public interface UserMapper {
 	@Select("SELECT * FROM USERS ")
 	List<User> findUserList();
 }

  6. service代码

 @Service
 public class UserService {
 	@Autowired
 	private UserMapper userMapper;

 	/**
 	 * page 当前页数<br>
 	 * size 当前展示的数据<br>
 	 * 作者: 每特教育-余胜军<br>
 	 * 联系方式:QQ644064779|WWW.itmayiedu.com<br>
 	 * 
 	 * @param page
 	 * @param size
 	 * @return
 	 */
 	public PageInfo<User> findUserList(int page, int size) {
 		// 开启分页插件,放在查询语句上面
 		PageHelper.startPage(page, size);
 		List<User> listUser = userMapper.findUserList();
 		// 封装分页之后的数据
 		PageInfo<User> pageInfoUser = new PageInfo<User>(listUser);
 		return pageInfoUser;
 	}

 }

  7. controller层代码：

 @RestController
 public class IndexController {
 	@Autowired
 	private UserService userService;
 	@RequestMapping("/findUserList")
 	public PageInfo<User> findUserList(int page, int size) {
 		return userService.findUserList(page, size);
 	}
 }

  8. 启动代码：

 @MapperScan("com.itmayiedu.mapper")
 @SpringBootApplication
 public class PageHelper {

 	public static void main(String[] args) {
 		SpringApplication.run(PageHelper.class, args);
 	}

 }

springboot整合使用springjpa
引入依赖：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.0.RELEASE</version>
</parent>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-jpa</artifactId>
	</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

创建实体类User

  @Entity(name = "users")
  public class UserEntity {
  	@Id
  	@GeneratedValue(strategy = GenerationType.IDENTITY)
  	private Integer id;
  	@Column(name = "name")
  	private String name;
  	@Column(name = "age")
  	private Integer age;
  }

创建UserDao类

  public interface UserDao extends JpaRepository<User, Integer> {//这样就可以继承这个类的增删改查。
  }

创建Controller类

  @RestController
  public class IndexController {
  	@Autowired
  	private UserDao userDao;
  	@RequestMapping("/jpaFindUser")
  	public Object jpaIndex(User user) {
  		Optional<User> userOptional = userDao.findById(user.getId());
  		User reusltUser = userOptional.get();
  		return reusltUser == null ? "没有查询到数据" : reusltUser;
  	}
  }

启动项目：

  @SpringBootApplication
  public class JpaApp {
  
  	public static void main(String[] args) {
  		SpringApplication.run(JpaApp.class, args);
  	}
  
  }

springboot整合多个数据源
配置文件增加数据源：

  ###datasource1
  spring.datasource.test1.driver-class-name = com.mysql.jdbc.Driver
  spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
  spring.datasource.test1.username = root
  spring.datasource.test1.password = root
  ###datasource2
  spring.datasource.test2.driver-class-name = com.mysql.jdbc.Driver
  spring.datasource.test2.jdbc-url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
  spring.datasource.test2.username = root
  spring.datasource.test2.password = root

配置数据源类

  //DataSource01
  @Configuration // 注册到springboot容器中
  @MapperScan(basePackages = "com.qxd.test01", sqlSessionFactoryRef = "test1SqlSessionFactory")
  public class DataSource1Config {
  	/** 
  	 * @methodDesc: 功能描述:(配置test1数据库)
  	 */
  	@Bean(name = "test1DataSource")
  	@ConfigurationProperties(prefix = "spring.datasource.test1")
  	@Primary
  	public DataSource testDataSource() {
  		return DataSourceBuilder.create().build();
  	}
  	/**
  	 * @methodDesc: 功能描述:(test1 sql会话工厂)
  	 */
  	@Bean(name = "test1SqlSessionFactory")
  	@Primary
  	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource)
  			throws Exception {
  		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  		bean.setDataSource(dataSource);
  		return bean.getObject();
  	}
  	/** 
  	 * @methodDesc: 功能描述:(test1 事物管理)
  	 */
  	@Bean(name = "test1TransactionManager")
  	@Primary
  	public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
  		return new DataSourceTransactionManager(dataSource);
  	}
  	@Bean(name = "test1SqlSessionTemplate")
  	@Primary
  	public SqlSessionTemplate testSqlSessionTemplate(
  			@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  		return new SqlSessionTemplate(sqlSessionFactory);
  	}
  }
  //DataSource2
  @Configuration // 注册到springboot容器中
  @MapperScan(basePackages = "com.qxd.test02", sqlSessionFactoryRef = "test2SqlSessionFactory")
  public class DataSource2Config {
  	/** 
  	 * @methodDesc: 功能描述:(配置test2数据库)
  	 */
  	@Bean(name = "test2DataSource")
  	@ConfigurationProperties(prefix = "spring.datasource.test2")
  	public DataSource testDataSource() {
  		return DataSourceBuilder.create().build();
  	}
  	/** 
  	 * @methodDesc: 功能描述:(test2 sql会话工厂)
  	 */
  	@Bean(name = "test2SqlSessionFactory")
  	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
  			throws Exception {
  		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  		bean.setDataSource(dataSource);
  		return bean.getObject();
  	}
  	/**
  	 * @methodDesc: 功能描述:(test2 事物管理)
  	 */
  	@Bean(name = "test2TransactionManager")
  	public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
  		return new DataSourceTransactionManager(dataSource);
  	}
  	@Bean(name = "test2SqlSessionTemplate")
  	public SqlSessionTemplate testSqlSessionTemplate(
  			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  		return new SqlSessionTemplate(sqlSessionFactory);
  	}
  }

创建mapper分包

  public interface User1Mapper {
  	@Insert("insert into users values(null,#{name},#{age});")
  	public int addUser(@Param("name") String name, @Param("age") Integer age);
  }

多数据源事务注意事项
在多数据源的情况下，使用@Transactional注解时，应该指定事务管理者
@Transactional(transactionManager = “test2TransactionManager”)
启动项目

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

五事务管理

springboot整合事务管理
Springboot默认集成事物,只主要在方法上加上@Transactional即可
分布式整合事务管理
使用springboot+jta+atomikos 分布式事物管理
Atomikos 是一个为Java平台提供增值服务的并且开源类事务管理器。
新增jta-atomikos依赖

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

新建配置文件

   # Mysql 1
   mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
   mysql.datasource.test1.username = root
   mysql.datasource.test1.password = root
   mysql.datasource.test1.minPoolSize = 3
   mysql.datasource.test1.maxPoolSize = 25
   mysql.datasource.test1.maxLifetime = 20000
   mysql.datasource.test1.borrowConnectionTimeout = 30
   mysql.datasource.test1.loginTimeout = 30
   mysql.datasource.test1.maintenanceInterval = 60
   mysql.datasource.test1.maxIdleTime = 60
   
   # Mysql 2
   mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
   mysql.datasource.test2.username =root
   mysql.datasource.test2.password =root
   mysql.datasource.test2.minPoolSize = 3
   mysql.datasource.test2.maxPoolSize = 25
   mysql.datasource.test2.maxLifetime = 20000
   mysql.datasource.test2.borrowConnectionTimeout = 30
   mysql.datasource.test2.loginTimeout = 30
   mysql.datasource.test2.maintenanceInterval = 60
   mysql.datasource.test2.maxIdleTime = 60

读取配置文件到类中

   @Data
   @ConfigurationProperties(prefix = "mysql.datasource.test1")
   public class DBConfig1 {
   
   	private String url;
   	private String username;
   	private String password;
   	private int minPoolSize;
   	private int maxPoolSize;
   	private int maxLifetime;
   	private int borrowConnectionTimeout;
   	private int loginTimeout;
   	private int maintenanceInterval;
   	private int maxIdleTime;
   	private String testQuery;
   }
   @Data
   @ConfigurationProperties(prefix = "mysql.datasource.test2")
   public class DBConfig2 {
   	private String url;
   	private String username;
   	private String password;
   	private int minPoolSize;
   	private int maxPoolSize;
   	private int maxLifetime;
   	private int borrowConnectionTimeout;
   	private int loginTimeout;
   	private int maintenanceInterval;
   	private int maxIdleTime;
   	private String testQuery;
   }

创建多数据源

       @Configuration
       // basePackages 最好分开配置 如果放在同一个文件夹可能会报错
       @MapperScan(basePackages = "com.itmayiedu.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
       public class MyBatisConfig1 {
       
       	// 配置数据源
       	@Primary
       	@Bean(name = "testDataSource")
       	public DataSource testDataSource(DBConfig1 testConfig) throws SQLException {
       		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
       		mysqlXaDataSource.setUrl(testConfig.getUrl());
       		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
       		mysqlXaDataSource.setPassword(testConfig.getPassword());
       		mysqlXaDataSource.setUser(testConfig.getUsername());
       		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
       
       		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
       		xaDataSource.setXaDataSource(mysqlXaDataSource);
       		xaDataSource.setUniqueResourceName("testDataSource");
       
       		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
       		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
       		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
       		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
       		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
       		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
       		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
       		xaDataSource.setTestQuery(testConfig.getTestQuery());
       		return xaDataSource;
       	}
       
       	@Primary
       	@Bean(name = "testSqlSessionFactory")
       	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
       			throws Exception {
       		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
       		bean.setDataSource(dataSource);
       		return bean.getObject();
       	}
       
       	@Primary
       	@Bean(name = "testSqlSessionTemplate")
       	public SqlSessionTemplate testSqlSessionTemplate(
       			@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
       		return new SqlSessionTemplate(sqlSessionFactory);
       	}
       }
       
       @Configuration
       @MapperScan(basePackages = "com.itmayiedu.test02", sqlSessionTemplateRef = "test2SqlSessionTemplate")
       public class MyBatisConfig2 {
       
       	// 配置数据源
   	@Bean(name = "test2DataSource")
   	public DataSource testDataSource(DBConfig2 testConfig) throws SQLException {
   		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
   		mysqlXaDataSource.setUrl(testConfig.getUrl());
   		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
   		mysqlXaDataSource.setPassword(testConfig.getPassword());
   		mysqlXaDataSource.setUser(testConfig.getUsername());
   		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
   
   		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
   		xaDataSource.setXaDataSource(mysqlXaDataSource);
   		xaDataSource.setUniqueResourceName("test2DataSource");
   
   		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
   		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
   		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
   		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
   		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
   		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
   		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
   		xaDataSource.setTestQuery(testConfig.getTestQuery());
   		return xaDataSource;
   	}
   	@Bean(name = "test2SqlSessionFactory")
   	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
   			throws Exception {
   		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
   		bean.setDataSource(dataSource);
   		return bean.getObject();
   	}
   	@Bean(name = "test2SqlSessionTemplate")
   	public SqlSessionTemplate testSqlSessionTemplate(
   			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
   		return new SqlSessionTemplate(sqlSessionFactory);
   	}
   }

启动代码

   @EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })

六日志管理

使用log4j记录日志
1. 配置文件

        #log4j.rootLogger=CONSOLE,info,error,DEBUG
          log4j.rootLogger=info,error,CONSOLE,DEBUG
          log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
          log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
          log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
          log4j.logger.info=info
          log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
          log4j.appender.info.layout=org.apache.log4j.PatternLayout     
          log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
          log4j.appender.info.datePattern='.'yyyy-MM-dd
          log4j.appender.info.Threshold = info   
          log4j.appender.info.append=true   
          #log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
          log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info
          log4j.logger.error=error  
          log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
          log4j.appender.error.layout=org.apache.log4j.PatternLayout     
          log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
          log4j.appender.error.datePattern='.'yyyy-MM-dd
          log4j.appender.error.Threshold = error   
          log4j.appender.error.append=true   
          #log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
          log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error
          log4j.logger.DEBUG=DEBUG
          log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
          log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
          log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
          log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
          log4j.appender.DEBUG.Threshold = DEBUG   
          log4j.appender.DEBUG.append=true   
          #log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
          log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug
          log4j代码
  private static final Logger logger = LoggerFactory.getLogger(IndexController.class);


   2. maven依赖
```java
  <parent>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-parent</artifactId>
  		<version>2.0.0.RELEASE</version>
  	</parent>
  	<dependencies>
  		<!-- SpringBoot 核心组件 -->
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-web</artifactId>
  		</dependency>
  		<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>
  		<!-- spring boot start -->
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter</artifactId>
  			<exclusions>
  				<!-- 排除自带的logback依赖 -->
  				<exclusion>
  					<groupId>org.springframework.boot</groupId>
  					<artifactId>spring-boot-starter-logging</artifactId>
  				</exclusion>
  			</exclusions>
  		</dependency>
  		<!-- springboot-log4j -->
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-log4j</artifactId>
  			<version>1.3.8.RELEASE</version>
  		</dependency>
  	</dependencies>

可以使用aop来将日志更简单
springboot整合lombok让代码简单
1. 添加lombok依赖

  <dependency>
  	<groupId>org.projectlombok</groupId>
  	<artifactId>lombok</artifactId>
  </dependency>

实体类演示

  @Slf4j
  @Data
  public class UserEntity {
  	// @Getter
  	// @Setter
  	private String userName;
  	// @Getter
  	// @Setter
  	private Integer age;
  	@Override
  	public String toString() {
  		return "UserEntity [userName=" + userName + ", age=" + age + "]";
  	}
  
  	public static void main(String[] args) {
  		UserEntity userEntity = new UserEntity();
  		userEntity.setUserName("zhangsan");
  		userEntity.setAge(20);
  		System.out.println(userEntity.toString());
  		log.info("####我是日志##########");
  	}
  }

其他特性
@Data 标签，生成getter/setter toString()等方法
@NonNull : 让你不在担忧并且爱上NullPointerException
@CleanUp : 自动资源管理：不用再在finally中添加资源的close方法
@Setter/@Getter : 自动生成set和get方法
@ToString : 自动生成toString方法
@EqualsAndHashcode : 从对象的字段中生成hashCode和equals的实现
@NoArgsConstructor/@RequiredArgsConstructor/@AllArgsConstructor
自动生成构造方法
@Data : 自动生成set/get方法，toString方法，equals方法，hashCode方法，不带参数的构造方法
@Value : 用于注解final类
@Builder : 产生复杂的构建器api类
@SneakyThrows : 异常处理（谨慎使用）
@Synchronized : 同步方法安全的转化
@Getter(lazy=true) :
@Log : 支持各种logger对象，使用时用对应的注解，如：@Log4

七缓存支持

注释配置Ehcache使用
1. 依赖引入

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

新建ehcache.xml 文件

  <?xml version="1.0" encoding="UTF-8"?>
  <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
  	updateCheck="false">
  	<diskStore path="java.io.tmpdir/Tmp_EhCache" />
  	<!-- 默认配置 -->
  	<defaultCache maxElementsInMemory="5000" eternal="false"
  		timeToIdleSeconds="120" timeToLiveSeconds="120"
  		memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />
  	<cache name="baseCache" maxElementsInMemory="10000"
  		maxElementsOnDisk="100000" />
  </ehcache>

配置信息介绍
1. name:缓存名称。
2. maxElementsInMemory：缓存最大个数。
3. eternal:对象是否永久有效，一但设置了，timeout将不起作用。
4. timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
5. timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternalfalse**对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
6. overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
7. diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
8. maxElementsOnDisk：硬盘最大缓存个数。
9. diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
10. diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
11. memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
12. clearOnFlush：内存数量最大时是否清除。
代码使用Cacheable

  @CacheConfig(cacheNames = "baseCache")
  public interface UserMapper {
  	@Select("select * from users where name=#{name}")
  	@Cacheable
  	UserEntity findName(@Param("name") String name);
  }

清除缓存

  @Autowired
  private CacheManager cacheManager;
  @RequestMapping("/remoKey")
  public void remoKey() {
  	cacheManager.getCache("baseCache").clear();
  }

启动加入缓存
@EnableCaching // 开启缓存注解

九监控管理

Actuator监控

Actuator监控应用
ACtuator是springboot的一个附加功能，可帮助你在应用程序生产环境时监控和管理应用程序。可以使用HTTP的各种请求来监管，审计，收集应用的运行情况，特别对于微服务管理十分有意义，缺点：没有可视化界面。
Maven依赖

   <parent>
   		<groupId>org.springframework.boot</groupId>
   		<artifactId>spring-boot-starter-parent</artifactId>
   		<version>2.0.0.RELEASE</version>
   	</parent>
   	<dependencies>
   		<dependency>
   			<groupId>org.springframework.boot</groupId>
   			<artifactId>spring-boot-starter-web</artifactId>
   		</dependency>
   		<dependency>
   			<groupId>org.springframework.boot</groupId>
   			<artifactId>spring-boot-starter-actuator</artifactId>
   		</dependency>
   	</dependencies>
   Mysql测试依赖信息
   <dependency>
   			<groupId>org.mybatis.spring.boot</groupId>
   			<artifactId>mybatis-spring-boot-starter</artifactId>
   			<version>1.1.1</version>
   		</dependency>
   		<!-- mysql 依赖 -->
   		<dependency>
   			<groupId>mysql</groupId>
   			<artifactId>mysql-connector-java</artifactId>
   		</dependency>

yml配置文件
###通过下面的配置启用所有的监控端点，默认情况下，这些端点是禁用的；

   management:
     endpoints:
       web:
         exposure:
           include: "*"
   spring:
     profiles:
       active: prod
     datasource:
       driver-class-name: com.mysql.jdbc.Driver
       url: jdbc:mysql://127.0.0.1:3306/test
       username: root
       password: root
   qxd: 
      name: qxd

Actuator访问路径
路径作用
/actuator/beans 显示应用程序中所有Spring bean的完整列表。
/actuator/configprops 显示所有配置信息。
/actuator/env 陈列所有的环境变量。
/actuator/mappings 显示所有@RequestMapping的url整理列表。
/actuator/health 显示应用程序运行状况信息 up表示成功 down失败
/actuator/info 查看自定义应用信息
配置
info:
qxd: qxd
addres: www.qxd.com
Admin-UI分布式微服务监控中心
Admin-UI基于actuator实现能够返回界面展示监控信息
Admin-UI-Server
1. Maven依赖：

<parent>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-parent</artifactId>
  		<version>2.0.0.RELEASE</version>
  	</parent>
  	<dependencies>
  		<dependency>
  			<groupId>de.codecentric</groupId>
  			<artifactId>spring-boot-admin-starter-server</artifactId>
  			<version>2.0.0</version>
  		</dependency>
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-webflux</artifactId>
  		</dependency>
  		<!-- Spring Boot Actuator对外暴露应用的监控信息，Jolokia提供使用HTTP接口获取JSON格式 的数据 -->
  		<dependency>
  			<groupId>org.jolokia</groupId>
  			<artifactId>jolokia-core</artifactId>
  		</dependency>
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-actuator</artifactId>
  		</dependency>
  		<dependency>
  			<groupId>com.googlecode.json-simple</groupId>
  			<artifactId>json-simple</artifactId>
  			<version>1.1</version>
  		</dependency>
  	</dependencies>

application.yml配置文件

  spring:
    application:
      name: spring-boot-admin-server

启动程序：

  @Configuration
  @EnableAutoConfiguration
  @EnableAdminServer
  public class AdminServerApplication {
  
  	public static void main(String[] args) {
  		SpringApplication.run(AdminServerApplication.class, args);
  	}
  }

Admin-UI-Client

maven配置：
org.springframework.boot spring-boot-starter-parent 2.0.0.RELEASE de.codecentric spring-boot-admin-starter-client 2.0.0 org.springframework.boot spring-boot-starter-actuator org.jolokia jolokia-core com.googlecode.json-simple json-simple 1.1 org.springframework.boot spring-boot-starter-web
yml配置文件

   spring:
     boot:
       admin:
         client:
           url: http://localhost:8080
   server:
     port: 8081
     
   management:
     endpoints:
       web:
         exposure:
           include: "*"
     endpoint:
       health:
         show-details: ALWAYS

启动类

   @SpringBootApplication
   public class AppClinet {
   
   	public static void main(String[] args) {
   		SpringApplication.run(AppClinet.class, args);
   	}
   }

十性能优化

组件自动扫描带来的问题
当包多的时候全部扫包的时候包多的时候，会使扫描包造成资源浪费启动时间多。
将servlet容器变成Undertow
1. 首先在maven中去除tomcat配置如下：

  <dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-web</artifactId>
  			<exclusions>
  				<exclusion>
  					<groupId>org.springframework.boot</groupId>
  					<artifactId>spring-boot-starter-tomcat</artifactId>
  				</exclusion>
  			</exclusions>
  		</dependency>

添加undertow配置

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

jvm调优
这个根据服务器的内存大小，来设置堆参数。
-Xms :设置Java堆栈的初始化大小
-Xmx :设置最大的java堆大小
实例参数-XX:+PrintGCDetails -Xmx32M -Xms1M

十一其他内容

@Scheduled定时任务
1. 使用@Scheduled创建定时任务
  在Spring Boot的主类中加入@EnableScheduling注解，启用定时任务的配置
2. 代码如下：

  @Component
  public class ScheduledTasks {
      private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
      @Scheduled(fixedRate = 5000)
      public void reportCurrentTime() {
          System.out.println("现在时间：" + dateFormat.format(new Date()));
      }
  }

@Async实现异步调用
1. maven依赖

  <parent>
  		<groupId>org.springframework.boot</groupId>
  		<artifactId>spring-boot-starter-parent</artifactId>
  		<version>2.0.0.RELEASE</version>
  	</parent>
  	<dependencies>
  		<dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-web</artifactId>
  		</dependency>
  		<dependency>
  			<groupId>org.projectlombok</groupId>
  			<artifactId>lombok</artifactId>
  		</dependency>
  	</dependencies>

演示代码

@RestController
      @Slf4j
      public class IndexController {
      	@Autowired
      	private UserService userService;
      	@RequestMapping("/index")
      	public String index() {
      		log.info("##01##");
      		userService.userThread();
      		log.info("##04##");
      		return "success";
      	}
      }
      @Service
      @Slf4j
      public class UserService {
      	@Async // 类似与开启线程执行..
      	public void userThread() {
      		log.info("##02##");
      		try {
      			Thread.sleep(5 * 1000);
      		} catch (Exception e) {
      			// TODO: handle exception
      		}
      		log.info("##03##");
      	}
      }
      @EnableAsync // 开启异步注解
      @SpringBootApplication
      public class App {
      	public static void main(String[] args) {
      		SpringApplication.run(App.class, args);
      	}
      }

qxdzy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springboot常用开发实现方法

springBoot微服务开发解决方案一 SpringBoot介绍springboot简介大家都知道以前的分布式开发项目，但是在配置这一方面上来看，很繁琐，而且很难记，现在开发的快速开发框架SpringBoot解决了这个地方。系统要求java1.8 以上的版本简化xml配置采用注解的方式默认内部继承SpringMVC框架现在都知道SpringBoot和SpringCl...
复制链接

扫一扫