springboot

SpringBoot的起步依赖

​ SpringApplication在运行Spring的应用时,会初始化Spring的工厂实例,加载spring.factories工厂配置文件,查找文件中key为EnableAutoConfiguration中的所有路径,判断对应的启动器是否被导入,如果导入就创建实例,自动注入默认属性添加到IOC容器.

SpringBoot的配置

概述

​ SpringBoot的配置可以使用2种配置文件来实现,分别是:properties后缀的文件和yml后缀的文件;properties文件的加载优先级会比yml文件的优先级高,但如果2者都存在,其中一部分配置在properties文件中,一部分配置在yml文件中,配置类容冲突的以properties文件为先,不冲突配置的都生效,但通常我们基本都是以yml作为配置文件。

​ 配置文件的名称是固定的，不管是properties或者yml文件，前缀必须是application作为文件名称。

properties后缀文件:

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/xxx
jdbc.username=root
jdbc.password=123

yml后缀文件:

jdbc:
	driverClassName: com.mysql.jdbc.Driver
	url: jdbc:mysql://127.0.0.1:3306/xxx
	username: root
	password: 123

yml配置文件的格式

# 注意: 冒号后面必须有空格
# 覆盖自动配置类的默认属性
server:
  port: 9002
  servlet:
    contextPath: /

# 定义自已项目中需要的属性
# 标量类型
my:
 host: 127.0.0.1
 port: 3306

 # 对象类型
 user:
   name: 小非
   age: 18
   sex: 男

 # 数组类型
 address:
   - 九巷
   - 八巷
   - 十巷

 # 对象数组类型
 users:
   - name: 张三
     age: 18
     sex: 女
   - name: 李四
     age: 20
     sex: 男	

读取配置文件的方式

@Component
@ConfigurationProperties("jdbc")
@Data
public class JdbcConfig{
    private String driverClassName;
    private String url;
    private String username;
    private String password;
}

SpringBoot访问静态资源

概述

​ 现在我们的SpringBoot工程是一个jar工程，没有webapp目录，我们的静态资源该放哪里呢?

​ SpringBoot已经给我们提供好了静态资源的存储路径，但注意这个存储路径是在编译后的路径资源下，并不是编译前的路径，定义好的静态资源路径如下：【我们需要手动去创建】

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public

SpringBoot整合lombok

1.导入依赖

<!-- 引入lombok -->
<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <scope>provided</scope>
</dependency>

2.使用lombok

@Data
public class User{
        private String username;
        private String password;
}

SpringBoot整合日志

概述

​ 由于SpringBoot已经帮我们集成好了日志的依赖,所以我们不需要添加日志的启动器。日志的输出级别:debug<info<warn<error

1.配置日志输出的方式

logging:
level:
	# com.javacat7包下所有的操作都会有日志输出
	# 日志级别: debug->info>->warn->error
  	com.javacat7: debug
  	# 输出到磁盘的位置
	file: F:\loggin.txt

2.使用日志

@RestController
@Slf4j // 日志注解
public class LogController {  
  @GetMapping("/log")
  public String log(){
      log.debug("====debug====");
      log.info("====info====");
      log.warn("====warn====");
      log.error("====error====");
      return "log....";
  }
}

SpringBoot整合SpringMVC

整合SpringMVC

1.导入启动器

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

2.具体使用

@RestController
public class UserController{
	@GetMapping("/save")
	public String saveUser(){
		return "添加成功";
	}
}

拦截器的定义

1.自定义拦截器

/** 定义拦截器 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
        /** 前置处理 */
        @Override
        public boolean preHandle(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler) throws Exception {
            log.debug("== preHandle 方法执行! ==");
            return true;
        }
        /** 后置处理 */
        @Override
        public void postHandle(HttpServletRequest request,
                               HttpServletResponse response,
                               Object handler,
                               ModelAndView modelAndView) throws Exception {
            log.debug("== postHandle 方法执行! ==");
        }
        /** 视图渲染之后 */
        @Override
        public void afterCompletion(HttpServletRequest request,
                                    HttpServletResponse response,
                                    Object handler, Exception ex) throws Exception {
            log.debug("== afterCompletion 方法执行! ==");
        }
}

2.注册拦截器

@Configuration
public class MvcConfiguration implements WebMvcConfigurer {
        /** 重写接口中的addInterceptors方法，添加自定义拦截器 */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 添加拦截器，通过addPathPatterns来添加拦截路径
            registry.addInterceptor(new LoginInterceptor())
                    .addPathPatterns("/**");
        }
}

SpringBoot整合Junit

1.导入Junit的启动器

<!-- 配置test启动器(自动整合spring-test、junit) -->
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
</dependency>

2.具体使用

// 运行主类
@RunWith(SpringRunner.class)
// 如果测试类在启动类的同级目录或者子目录下可以省略指定启动类
//@SpringBootTest(classes = {HighApplication.class})
@SpringBootTest
public class UserServiceTest {
    
}

SpringBoot整合Redis

1.导入Redis启动器

<!-- 配置redis启动器 -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.配置Redis的服务器

# 配置Redis
spring:
     redis:
           host: localhost # 主机
           port: 6379      # 端口
           database: 0     # 使用的数据库

3.具体使用

public class TestDemo{
     @Autowired
     private RedisTemplate redis;
}

SpringBoot整合JDBC

1.导入JDBC启动器

<!-- 配置jdbc启动器 -->
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- 配置mysql驱动 -->
<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
</dependency>

2.配置数据库连接参数

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

SpringBoot整合Mybatis

1.导入依赖包

<!--mybatis启动器-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.1</version>
</dependency>
<!-- 配置mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

2.配置文件

spring:
  datasource:
    username: root
    password: chentian.manager
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://47.108.24.70:3306/test?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=true
mybatis:
  mapper-locations: classpath:mapper/UserDao.xml
  type-aliases-package: com.javacat7.entity

3.启动器

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

4.配置接口映射xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace= "com.javacat7.mapper.UserDao">
    <select id="findAllUser" resultType="com.javacat7.entity.User">
        select * from user
    </select>
</mapper>

SpringBoot整合通用Mapper

1.导入启动器

<!-- 配置通用Mapper启动器 -->
<dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.1.5</version>
</dependency>

2.在要操作的ORM对象中设置对应的表

@Data
@Table(name = "tb_user")
public class User{
	// 用户id
	@Id // 主键
	@KeySql(useGeneratedKeys = true) // 开启自增主键返回功能
	private Long id;
	private String userName;
	private String password;
	private String name;
	private Integer age;
}

3.在数据访问层指定要操作的对象

//@Mapper // 声明数据访问接口，产生代理对象
public interface UserMapper extends Mapper<User> {
  	
}

4.在启动类添加包扫描

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

SpringBoot整合MybatisPlus

1.导入启动器

<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.1.0</version>
</dependency>

2.配置开启

mybatis-plus:
    # 使用mybatis-plus   映射别名
    type-aliases-package: com.leyou.item.entity
    configuration:
       # 支持驼峰
       map-underscore-to-camel-case: true
    # 开启扫描包
    mapper-locations: mapper/*.xml

3.在要操作的ORM对象中设置对应的表

@Data
@TableName("le_user")   //数据库的表名称
public class User{
        @TableId(type = IdType.AUTO)   //自动增长
        private Long id;
        @TableFilder("user_name") //数据库中的表字段和实体类的表字段映射
        private String username;
        private String password;
}

4.在数据访问层指定要操作的对象

/**
	所有持久层的接口必须 继承 -> BaseMapper
	并且泛型中添加 接口与数据库交互的对象 例如: User
*/
public interface UserMapper extends BaseMapper<User>{    }


/**
	业务层与数据库交互,由于MyBatisPlus没有提供添加一个集合和删除一个集合的方法,我们需要继承ServiceImple,因为该类中已经给我们提供了这些方法;
	需要制定2个泛型:
		1: 链接数据库的具体接口
		2: 链接来接该数据库使用的实体参数对象
*/
@Service
@Transactinal
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService{
        @Autowired
        private UserMapper userMapper;
}

5.在启动类添加包扫描

@SpringBootApplication
@MapperScan(basePackge="com.javacat7.mapper")
public class UserServiceApplication{
	public static void main(String [] args){
		SpringApplication.run(UserServiceApplication.class,args);
	}
 
 //创建mybatis-plus分页拦截器，加入IOC容器
  	@Bean
  	public PaginationInterceptor createPaginationInterceptor(){
          return new PaginationInterceptor();
      }
}

SpringBoot整合RabbitMQ

1.导入需要的启动器

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

2.消息发送方

yml配置文件

spring:
  	rabbitmq:
            host: 192.168.99.100 #rabbitmq服务器的地址
            port: 5672 #rabbitmq使用代码链接的端口
            virtual-host: /rabbitmq-test # 虚礼主机
            username: test #用户名
            password: test #密码

交换机队列设置绑定配置类

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitQueueConfig {
    	public static final String EXCHANGE_NAME="boot_exhange";
    	public static final String QUEUE_NAME="boot_queue";

        @Bean("bootExchange")
        public Exchange createExchange(){
            return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
        }

        @Bean("bootQueue")
        public Queue createQueue(){
            return QueueBuilder.durable(QUEUE_NAME).build();
        }

        @Bean("bootBinding")
        public Binding createBinding(@Qualifier("bootExchange") Exchange exchange,
                                     @Qualifier("bootQueue") Queue queue){
            return BindingBuilder.bind(queue).to(exchange).with("user.#").noargs();
        }

}

发送消息到队列

@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitMQProducerApplication.class)
public class RabbitProducerTest {
    @Autowired
    private AmqpTemplate rabbitMQTemplate;

    @Test
    /**
    	参数一:交换机
    	参数二:routingKey
    	参数三:发送到队列的信息
    */
    public void testProducer(){
        rabbitMQTemplate.convertAndSend(RabbitQueueConfig.EXCHANGE_NAME,"user.demo","hello");
    }
}

3.消息接收方

yml配置文件

spring:
  rabbitmq:
    host: 192.168.99.100 #rabbitmq服务器的地址
    port: 5672 #rabbitmq使用代码链接的端口
    virtual-host: /rabbitmq-test # 虚礼主机
    username: test #用户名
    password: test #密码

监听消费消息

@Component
public class ListernalQueue {

    @RabbitListener(queues = "boot_queue")
    public void isternal(Message message){
        System.out.println(message);
    }
}

SpringBoot项目打包部署

1.导入打包插件

<build>
    <plugins>
        <!-- 配置spring-boot的maven插件
                1. 用它可以运行spring-boot项目
                2. 需要用它构建打jar、war资料
             -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2.打成jar包

# 清理、打包
mvn clean package
# 清理、打包 跳过测试
mvn clean package -Dmaven.test.skip=true
# 运行项目
java -jar xxx.jar

3.打成war包

<!-- 打包方式(默认为jar) -->
<packaging>war</packaging>

<!--
       配置tomcat启动器，就会排除spring-boot-starter-web中依赖过来的tomcat启动器
       指定scope为provided: 代表打war包时，不需要它的依赖jar包(我们有自己的tomcat)
-->
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
</dependency>

<!--修改工程的名字为ROOT-->
<build>
        <!-- 指定最终打成war的项目名称 -->
        <finalName>ROOT</finalName>
</build>

/** 
	自定义web应用入口类继承SpringBootServletInitializer
	web应用入口 
*/
public class WebServletInitializer extends SpringBootServletInitializer {
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
            // 设置启动类
            builder.sources(HighApplication.class);
            // 返回spring应用构建对象
            return builder;
        }
}