SpringBoot2.x系列二：整合第三方组件Mybatis、JPA、Redis、Elasticsearch、ActiveMQ、Kafka、Logback

一、整合Mybatis及事务

（1）加入依赖

<!-- 引入starter-->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.3.2</version>
	<scope>runtime</scope>			    
</dependency>
<!-- MySQL的JDBC驱动包	-->	
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency> 
<!-- 引入第三方数据源 -->		
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.6</version>
</dependency>

（2）加入配置文件

#mybatis.type-aliases-package=net.xdclass.base_project.domain
#可以自动识别
#spring.datasource.driver-class-name =com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/movie?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
#如果不使用默认的数据源 （com.zaxxer.hikari.HikariDataSource）
spring.datasource.type =com.alibaba.druid.pool.DruidDataSource
#驼峰命名转换
mybatis.configuration.mapUnderscoreToCamelCase=true
#控制台打印sql语句		
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

（3）启动类增加注解扫描 mapper

@MapperScan("com.neusoft.mapper")

（4）mapper接口开发

public interface UserMapper {

	//推荐使用#{}取值，不要用${},因为存在注入的风险
	@Insert("INSERT INTO user(name,phone,create_time,age) VALUES(#{name}, #{phone}, #{createTime},#{age})")
	@Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id")//获取自增id
	int insert(User user);

	@Select("SELECT * FROM user")
	List<User> getAll();

	//开启驼峰命名转换可省略@Results注解中的字段映射
	@Select("SELECT * FROM user WHERE id = #{id}")
	//@Results({@Result(column = "create_time",property = "createTime")})
	User findById(Long id);
}

（5）业务逻辑层调用略
sql脚本如下

CREATE TABLE `user` (
	  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
	  `name` varchar(128) DEFAULT NULL COMMENT '名称',
	  `phone` varchar(16) DEFAULT NULL COMMENT '用户手机号',
	  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
	  `age` int(4) DEFAULT NULL COMMENT '年龄',
	  PRIMARY KEY (`id`)
	) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;

（6）mapper开发语法参考
http://www.mybatis.org/mybatis-3/zh/java-api.html
（7）mybatis之事务处理

//service逻辑层引入事务
@Transantional(propagation=Propagation.REQUIRED)

（8）常见的传播行为
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务,最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起, 两个事务之间没有关系，一个异常，一个提交，不会同时回滚
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常

二、整合JPA

JPA全称Java Persistence API.JPA，通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
jpa在复杂查询的时候性能不是很好
（1）添加相关依赖

<!-- JPA -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- MySQL的JDBC驱动包 -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency>
<!-- 引入第三方数据源 -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.6</version>
</dependency>

（2）配置文件

#=========MySQL配置=========
spring.datasource.url=jdbc:mysql://localhost:3306/movie?useUnicode=true&characterEncoding=utf-8
spring.datasource.username =root
spring.datasource.password =root
##如果不使用默认的数据源 （com.zaxxer.hikari.HikariDataSource）
spring.datasource.type =com.alibaba.druid.pool.DruidDataSource
#=========JPA配置=========
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

（3）创建实体类

@Entity
public class User {
	@Id
	@GeneratedValue
	private Integer id;
	@Column
	private String name;
	@Column
	private Integer age;
	public Integer getId() {
	
		return id;
	}
	public void setId(Integer id) {
	
		this.id = id;
	}
	public String getName() {
	
		return name;
	}
	public void setName(String name) {
	
		this.name = name;
	}
	public Integer getAge() {
	
		return age;
	}
	public void setAge(Integer age) {
	
		this.age = age;
	}
}

（4）Dao层

public interface UserDao extends JpaRepository<User, Integer> {

}

（5）Web层

@RestController
public class IndexController {

	@Autowired
	private UserDao userDao;

	@RequestMapping("/index")
	public User index(Integer id) {
		return userDao.findOne(id);
	}
}

三、整合Redis

（1）redis在线测试工具：http://try.redis.io/
redis window版点击下载解压直接运行redis-server.exe即可,下载地址：https://github.com/MicrosoftArchive/redis/releases
redis教程及Linux版安装点击跳转见博客https://blog.csdn.net/zhou870498/article/details/79904475
（2）springboot整合redis相关依赖引入

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

  （3）相关配置文件配置

#=========redis基础配置=========
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
#如果有密码
spring.redis.password=
# 连接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000
#=========redis线程池设置=========
# 连接池中的最大空闲连接，默认值也是8。
spring.redis.jedis.pool.max-idle=200
#连接池中的最小空闲连接，默认值也是0。
spring.redis.jedis.pool.min-idle=200
# 如果赋值为-1，则表示不限制；pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
spring.redis.jedis.pool.max-active=2000
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时
spring.redis.jedis.pool.max-wait=1000

（4）redistemplate操作redis

@RestController
public class IndexController {
	@Autowired
	private StringRedisTemplate redisTpl;

	@RequestMapping("testRedis")
	public Object index(){
		redisTpl.opsForValue().set("name","xiaoLuo");
		String name = redisTpl.opsForValue().get("name");
		return name;
	}
}

四、整合Elasticsearch

（1）整合步骤
①SpringBoot整合elasticsearch版本说明：
https://github.com/spring-projects/spring-data-elasticsearch/wiki/Spring-Data-Elasticsearch---Spring-Boot---version-matrix
②添加maven依赖

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

③配置文件：

spring.data.elasticsearch.cluster-name=elasticsearch
spring.data.elasticsearch.cluster-nodes=localhost:9300
spring.data.elasticsearch.repositories.enabled=true

④新建实体对象article，加上注解 @Document(indexName = "blog", type = "article")
示例：

@Document(indexName = "blog", type = "article")
public class Article implements Serializable{
	private static final long serialVersionUID = 1L;

	private long id;
	
	private String title;
	
	private String summary;
	
	private String content;
	
	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getSummary() {
		return summary;
	}

	public void setSummary(String summary) {
		this.summary = summary;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}
}

⑤接口继承ElasticSearchRepository,里面有很多默认实现
示例：

@Component 
public interface ArticleRepository extends ElasticsearchRepository<Article, Long> {

}

⑥调用示例

@RestController
public class ArticleController {


	@Autowired
	private ArticleRepository articleRepository;
	
	@GetMapping("save")
	public Object save(long id,String title){
		Article article = new Article();
		article.setId(id);
		article.setContent("springboot整合elasticsearch");
		article.setTitle(title);
		article.setSummary("搜索框架整合");
		articleRepository.save(article);
		return "ok";
	}


	@GetMapping("search")
	public Object search(String title){
		//QueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); //搜索全部文档
		QueryBuilder queryBuilder = QueryBuilders.matchQuery("title", title);
		Iterable<Article> list =  articleRepository.search(queryBuilder);
		return JsonData.buildSuccess(list);
	}
}

（2）QueryBuilder复杂条件查询使用
https://www.elastic.co/guide/en/elasticsearch/client/java-api/1.3/query-dsl-queries.html
（3）更多教程参见本博客 elasticsearch系列

五、整合ActiveMQ

window下载地址：点击打开链接
windows版下载解压运行bin/win64文件夹下的activemq.bat
访问地址：http://127.0.0.1:8161/
1.点对点消息(p2p)
①添加依赖

<!-- 整合消息队列ActiveMQ -->
<dependency>  
	<groupId>org.springframework.boot</groupId>  
	<artifactId>spring-boot-starter-activemq</artifactId>  
</dependency>  
<!-- 如果配置线程池则加入 -->
<dependency>  
	<groupId>org.apache.activemq</groupId>  
	<artifactId>activemq-pool</artifactId>  
</dependency>

②配置文件

#=========ActiveMQ=========
spring.activemq.broker-url=tcp://127.0.0.1:61616
#集群配置
#spring.activemq.broker-url=failover:(tcp://localhost:61616,tcp://localhost:61617)
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=100

③springboot启动类添加注解 @EnableJms，开启支持jms
④生产者：生产消息

public interface ProducerService {
	/**
	 * 功能描述：指定消息队列，还有消息
	 * @param destination
	 * @param message
	 */
	public void sendMessage(Destination destination, final String message);
}

@Service
public class ProducerServiceImpl implements ProducerService {

	@Autowired
	private JmsMessagingTemplate jmsTemplate; //用来发送消息到broker的对象
	
	//发送消息，destination是发送到的队列，message是待发送的消息
	@Override
	public void sendMessage(Destination destination, String message) {
		jmsTemplate.convertAndSend(destination, message);
		
	}
}

⑤消费者：实时监听对应的队列

@Component
public class OrderConsumer {

	@JmsListener(destination="order.queue")
	public void receiveQueue(String text){
		System.out.println("OrderConsumer收到的报文为:"+text);
	}
}

⑥调用

@RestController
@RequestMapping("/api/v1")
public class OrderController {
	
	@Autowired
	private ProducerService producerService;


	@GetMapping("order")
	public Object order(String msg){
		Destination destination = new ActiveMQQueue("order.queue");
		producerService.sendMessage(destination, msg);
       return "ok";
	}
}

2.发布订阅消息(pub/sub)
①添加依赖同点对点
②配置文件

#=========ActiveMQ=========
spring.activemq.broker-url=tcp://127.0.0.1:61616
#集群配置
#spring.activemq.broker-url=failover:(tcp://localhost:61616,tcp://localhost:61617)
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=100

#添加支持发布订阅模型，默认只支持点对点
spring.jms.pub-sub-domain=true

③启动类

@EnableJms
@SpringBootApplication
public class TestActivemqApplication {

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

	//主题对象交给spring管理
	@Bean
	public Topic topic(){
		return new ActiveMQTopic("video.topic");
	}
}

④生产者

public interface ProducerService {

	/**
	 * 功能描述：消息发布者
	 * @param msg
	 */
	void publish(String msg);
}

@Service
public class ProducerServiceImpl implements ProducerService {

	@Autowired
	private JmsMessagingTemplate jmsTemplate; //用来发送消息到broker的对象
	@Autowired
	private Topic topic;

	@Override
	public void publish(String msg) {
		this.jmsTemplate.convertAndSend(this.topic, msg);
	}
}

⑤消费者

@Component
public class TopicSub {


	@JmsListener(destination="video.topic")
	public void receive1(String text){
		System.out.println("video.topic 消费者:receive1="+text);
	}
	
	@JmsListener(destination="video.topic")
	public void receive2(String text){
		System.out.println("video.topic 消费者:receive2="+text);
	}
	
	@JmsListener(destination="video.topic")
	public void receive3(String text){
		System.out.println("video.topic 消费者:receive3="+text);
	}
}

⑥调用

@RestController
@RequestMapping("/api/v1")
public class TopicController {
	
	@Autowired
	private ProducerService producerService;


	@GetMapping("topic")
	public Object topic(String msg){
		producerService.publish( msg);
       return "ok";
	}
}

3.点对点模式和发布订阅者模式共存需要添加或修改配置如下
①启动类中
//需要给topic定义独立的JmsListenerContainer

@Bean
public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
	DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
	bean.setPubSubDomain(true);
	bean.setConnectionFactory(activeMQConnectionFactory);
	return bean;
}

②订阅者中

//@JmsListener如果不指定独立的containerFactory的话是只能消费queue消息
@JmsListener(destination="video.topic", containerFactory="jmsListenerContainerTopic")
public void receive1(String text){
	System.out.println("video.topic 消费者:receive1="+text);
}

③在配置文件里面，注释掉 #spring.jms.pub-sub-domain=true

六、整合Kafka

（1）在Linux或Windows安装运行Kafka自行百度
（2）引入springboot-kafka的jar包依赖。

<dependency>
	<groupId>org.springframework.kafka</groupId>
	<artifactId>spring-kafka</artifactId>
</dependency>

（3）添加配置信息

spring.kafka.bootstrap-servers=127.0.0.1:9092
spring.kafka.consumer.group-id=myGroup

（4）创建生产者服务

package com.neusoft.kafka;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class ProviderService {

	@Autowired
	private KafkaTemplate<String,String> kafkaTemplate;


	public void sender(String topic,String value){
		kafkaTemplate.send(topic,value);
	}
}

（5）创建消费者服务，开启监听

package com.neusoft.kafka;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;

@Component
public class ConsumerService {

	@Resource
	private KafkaTemplate<String,String> kafkaTemplate;

	@KafkaListener(topics = "mytopics")
	public void consumer(String message){
		System.out.println("======="+message);
	}
}

（6）调用示例

package com.neusoft.controller;
import com.neusoft.kafka.ProviderService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
public class IndexController {

	@Resource
	private ProviderService providerService;

	@RequestMapping("index")
	public Object index(String name){
		for (int i = 0; i < 5; i++) {
			providerService.sender("mytopics",name+" test... "+i);
		}
		return "ok";
	}
}

七、整合Logback日志框架

1.新日志框架LogBack介绍
（1）常用处理java的日志组件 slf4j,log4j,logback,common-logging 等
（2）logback介绍：基于Log4j基础上大量改良，不能单独使用，推荐配合日志框架SLF4J来使用
logback当前分成三个模块：logback-core,logback-classic和logback-access;
（3）Logback的核心对象：
Logger：日志记录器
Appender：指定日志输出的目的地，目的地可以是控制台，文件
Layout：日志布局 格式化日志信息的输出
（4）日志级别：DEBUG < INFO < WARN < ERROR

===========log4j示例===========		
	 ### 设置###
	log4j.rootLogger = debug,stdout,D,E
	### 输出信息到控制抬 ###
	log4j.appender.stdout = org.apache.log4j.ConsoleAppender
	log4j.appender.stdout.Target = System.out
	log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
	log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
	### 输出DEBUG 级别以上的日志到=D://logs/error.log ###
	log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
	log4j.appender.D.File = D://logs/log.log
	log4j.appender.D.Append = true
	log4j.appender.D.Threshold = DEBUG 
	log4j.appender.D.layout = org.apache.log4j.PatternLayout
	log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
	### 输出ERROR 级别以上的日志到=D://logs/error.log ###
	log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
	log4j.appender.E.File =E://logs/error.log 
	log4j.appender.E.Append = true
	log4j.appender.E.Threshold = ERROR 
	log4j.appender.E.layout = org.apache.log4j.PatternLayout
	log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n 
	===========logback============

（5）Log4j日志转换为logback在线工具（支持log4j.properties转换为logback.xml,不支持 log4j.xml转换为logback.xml）
https://logback.qos.ch/translator/
2.SpringBoot2.x整合Logback配置(见文件)
创建日志文件logback-spring.xml，官方推荐 -spring.xml结尾。默认加载加载配置顺序 logback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy
注释：
<configuration> 子节点
<appender></appender>  
<logger></logger>
<root></root>(要加在最后)