SpringBoot2.X整合组件

1.整合Mybatis和Mapper

1.Mybatis的核心配置文件不用配置了，如果不需要自写mapper映射，mapper.xml文件也可不写；
2.在application.xml 或 application.yml 中对 Mybatis 和 Mapper 进行配置；
3.Mybatis 的 Dao 接口继承 tk.mybatis.mapper.common.Mapper 接口；
4.在实体pojo类上注解@Table(name="表名 ")，主键上注解@ID，属性名与列名需一一对应（支持驼峰），或者添加注解@Column(name="列名 ")。

引入依赖

Mybatis、Mapper和MySQL连接。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

注解pojo类

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="employee")
@Data		//添加了lomok依赖，注解@Data后，自动对属性添加setter、getter方法。
public class Employee  implements Serializable  {		//可序列化
    @Id
    private Integer emp_id;
    private String emp_name;
    private Integer emp_idtype;
    private String emp_idnumber;
    private Integer emp_permission;
    private String emp_account;
    private String emp_password;

注解Dao接口

import com.picc.hb.arg.serveremployee.pojo.Employee;
import org.apache.ibatis.annotations.Mapper;

@Mapper	
public interface EmployeeMapper extends tk.mybatis.mapper.common.Mapper<Employee> {

}

配置application.xml

#在格式：logging.level.Mapper类的包=debug  会在控制台打印出sql语句
#level.后面的com.picc.hb.arg.serveremployee.mapper是mapper接口所在的包名
logging.level.com.picc.hb.arg.serveremployee.mapper=debug

#数据库连接信息
spring.datasource.url=jdbc:mysql:///picc.hb
spring.datasource.username=root
spring.datasource.password=mysqladmin
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#mybatis&&通用Mapper
#扫描实体类pojo的所在包
mybatis.type-aliases-package=com.picc.hb.arg.serveremployee.pojo
#如果不是纯注解 mapper接口对应的.xml文件
#mybatis.mapper-locations=classpath:mapper/*.xml
#通用mapper的所在接口名称 不只是包名
mapper.mappers=com.picc.hb.arg.serveremployee.mapper.EmployeeMapper
#数据库认证
mapper.identity=MYSQL

2.整合Dubbo和Zookeeper

以下内容参考SnoWalker的文章，向原作者致敬！

引入依赖

必须依赖：dubbo-spring-boot-starter 2.0.0以及zkclint。

由于2.0.0版本的 dubbo-spring-boot-starter
对应的dubbo版本为2.6.0，因此需要依赖zkclient，后续的高版本使用的zookeeper客户端为apache-curator。

     <!-- 这里是ali的依赖，不要引入apache的，友情提示 -_-!  -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.11</version>
        </dependency>

服务接口的注册和调用

provider需在提供服务类上添加@Service注解，
consumer要在调用服务处添加@Reference取代Autowired。
两处注解中的interfaceClass属性应保持一致。如不填写，springboot亦会自动装配。

----------------Provider----------------

import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

@Service(interfaceClass = EmployeeServer.class)
@Component
public class EmployeeServerImp implements EmployeeServer {
    @Autowired
    private EmployeeMapper employeeMapper;
    @Override
    public Employee check(Employee employee) {
       /**
       *此处为业务代码
       */
    }
}

----------------Consumer----------------

import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ControllerDemo {
    /**
     *     @Reference
     *     如果添加interfaceClass = XXX.class，则按照interfaceClass =XXX.class
     *     对应的接口寻找
     *     如果不添加则按照注解的接口寻找服务
     */
    @Reference(interfaceClass = EmployeeServer.class, check = false)
    private EmployeeServer employeeServer;
    
    @RequestMapping("/hello")
    public String hello(@RequestBody Employee employee){
        System.out.println(employee);
        return employeeServer.check(employee).toString();
    }
}

配置文件Application.xml

provider和consumer不在同一war包中发布，需要配置到不同的端口。
两处皆需配置zookeeper作为注册中心。
如需同时作为provider和consumer则需加入 spring.dubbo.server = true 。

----------------Provider----------------

#发布端口，不一致即可
server.port=8083

## Dubbo 服务提供者配置
#标识，基本没用
spring.dubbo.application.name=provider
spring.dubbo.registry.address=zookeeper://192.168.37.134:2181
#默认的dubbo端口，如有变更需要修改
spring.dubbo.protocol.name=dubbo
spring.dubbo.protocol.port=20880
#如需同时作为provider和consumer则需修改为true
spring.dubbo.server=true

----------------Consumer----------------

#发布端口，不一致即可
server.port=8082

## Dubbo 服务消费者配置
spring.dubbo.application.name=consumer
spring.dubbo.registry.address=zookeeper://192.168.37.134:2181
spring.dubbo.server=true

启动类标注开启dubbo自动装配支持

需要在provider和consumer的启动类上添加注释@EnableDubboConfiguration，两处一样。

import com.alibaba.dubbo.spring.boot.annotation.EnableDubboConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableDubboConfiguration
@SpringBootApplication
public class DemoApplication {

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

3.整合Redis

引入依赖

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

redis配置application.xml

#Redis配置
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=192.168.37.134
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=123456
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-activ=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8  
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0  
# 连接超时时间（毫秒）
spring.redis.timeout=360

直接调用RedisTemplate即可

import org.springframework.data.redis.core.RedisTemplate;

@RestController
public class CtrollerTest {
    @Autowired
    private RedisTemplate<String,String> rt;
    @RequestMapping("/hello")
    public void hello()
    {
        rt.opsForValue().set("luking","liuxx");
        System.out.println(rt.opsForValue().get("luking"));
    }
}

4.整合RabbitMQ

引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>

RabbitMQ配置（application.xml）

##RabbitMQ配置
spring.rabbitmq.host=192.168.37.134
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#虚拟主机路径
spring.rabbitmq.virtual-host=/luking
#并发消费者的初始化值
spring.rabbitmq.listener.concurrency=10
#并发消费者的最大值
spring.rabbitmq.listener.max-concurrency=20
#每个消费者每次监听时可拉取处理的消息数量
spring.rabbitmq.listener.prefetch=5

RabbitMQ生产者Productor的配置类

--------------------只有一个队列和一个交换机的情况--------------------

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * RabbitMQ配置类
 * 提供交换机、队列和绑定方式的@Bean
 */
@Configuration
public class mqproductor {
	//创建名为“direct01”的定向交换机
    @Bean
    public Exchange directExchange01() {
        return ExchangeBuilder.directExchange("direct01").build();
    }
    //创建名为“message.queue”的队列
    @Bean
    public Queue queue01() {
        return QueueBuilder.durable("message.queue").build();
    }
    //由于交换机和队列都是单个，入参处的exchange和queue可以自动装配：将交换机和队列用routingkey（message.direct01.queue）绑定。
    @Bean
    public Binding bindingdq(Exchange exchange, Queue queue) {
        return BindingBuilder.bind(queue).to(exchange).with("message.direct01.queue").noargs();
    }
}

--------------------多个队列和多个交换机的情况--------------------

当项目中有多个交换机和队列是，需要在绑定routingkey的入参处@Qualifier指定Bean。

    @Bean
    public Binding bindingdq(@Qualifier("topicExchange02") Exchange exchange, @Qualifier("queue02") Queue queue) {
        return BindingBuilder.bind(queue).to(exchange).with("#.queue").noargs();
        // 通配符： #表示多个单词，*表示一个词
    }

RabbitMQ生产者发出消息

使用RabbitTemplate发送消息。

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
public class CtrollerTest {
   @Autowired
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/hello")
    public void hello()
    {
        /*参数
        * 交换机：       direct02
        * routingKey：  message.error.queue
        * 传递内容：     Object对象
        * */
        rabbitTemplate.convertAndSend("direct02","message.erroe.queue","this is erroe message");
    }
}

RabbitMQ消费者接收消息

配置文件的配置是相同的，接收的方法上注解@RabbitListener指定接收的队列即可。

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RabbitListerner {
    @RabbitListener(queues = {"error.queue"})
    //入参与传递的对象保持一致即可，可以自动进行转换
    public void res(String message){
        System.out.println(message);
    }
}