SpringBoot

1. SpringBoot简介

 1.1 Spring的优点和缺点分析

优点: 相对于EJB,Spring是轻量级的.通过IOC和AOP及pojo,非侵入性就能实现EJB的功能.
缺点: 配置过于繁琐,而且导入依赖的时候,依赖的jar包比较多,容易导入或版本弄错,从而导致启动和运行异常

 1.2 SpringBoot概述

  1.2.1 SpringBoot的特点

SpringBoot的特点就是简化了之前传统Spring的一些配置和依赖的繁琐问题,让我们快速的使用上Spring的技术.
开箱即用,没有代码生成,也无需xml配置.
SpringBoot不是对Spring功能的增强,而是提供了一种快速使用Spring的方式.

  1.2.2 SpringBoot的核心功能

(1)起步依赖(启动器)
起步依赖本质上是一个Maven对项目的对象模型(Project Object Model),我们需要用到上述技术的时候,需要导入对应技术的一个启动器依赖即可,不再像以前那样为了使用到一个技术需要导入多个jar包的依赖.

(2)自动配置(自动装配)
其实很多项目用到相同技术在配置上大体都是差不多的,所以SpringBoot就把这些配置定义成约定(默认)的配置.那这样我们在使用到对应技术的时候用默认配置就可以跑起来了,当然如果默认配置不能满足我们的业务需要,我们可以在SpringBoot的核心配置文件application.properties中进行修改制定.

2. SpringBoot快速入门

 2.1 普通创建SpringBoot工程的步骤

第一步: 创建maven普通的java工程
第二步: 在pom.xml中配置parent指向spring-boot-starter-parent

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.1.RELEASEversion>
    parent>

第三步: 配置所需的启动依赖,SpringBoot要集成SpringMVC进行Controller的开发,所以项目要导入web的启动依赖.

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

第四步: 创建引导类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

@SpringBootApplication:标注SpringBoot的启动类,该注解具备多种功能.
SpringApplication.run(SpringBootApplication.class):代表运行SpringBoot的启动类,参数为SpringBoot启动类的字节码对象.
第五步: 编写Controller

@Controller
public class HelloController {
    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "hello springboot!!!";
    }
}

第六步: 测试
首先启动启动类SpringBootApplication.Java

 2.2 SpringBoot工程热部署

所谓的热部署就是我们在开发中反复修改类,页面等资源,每次修改后都需要重新启动才能生效,这样每次启动都很麻烦,所以我们可以在修改代码后不重启就能生效,可以在pom.xml文件中配置就可以实现热部署.

 
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
        dependency>

因为idea默认情况下不会自动编译,所以要对idea进行配置.

然后Shift+Ctrl+Alt+/

 2.3 使用idea快速创建SpringBoot项目

 2.4 SringBoot中tomcat端口修改

在src/main/resources下创建application.properties

server.port=8088

读取配置文件中的信息
在src/main/resources下的application.properties 增加配置

url=http://www.baidu.com

	@Autowired
	private Environment env;

	@RequestMapping("/info")
	public String info(){
		return "HelloWorld~~"+env.getProperty("url");
	}

3. SpringBoot原理分析

 3.1 起步依赖原理分析

  3.1.1 分析spring-boot-starter-parent

所有的SpringBoot项目都必须继承spring-boot-starter-parent,
spring-boot-starter-parent又继承了spring-boot-dependencies,
spring-boot-dependencies中可以发现,一部分坐标的版本,依赖管理,插件管理已经定义好.所以起步依赖的作用就是进行依赖传递和版本控制.

  3.1.2 分析spring-boot-starter-web

web功能的起步依赖,它将web开发要使用的spring-web,spring-webmvc等坐标进行了打包,我们只需要引入spring-boot-starter-web起步依赖的坐标就可以完成web开发了.

 3.2 自动配置原理分析

自动配置就是将一些默认的东西加载进去,不需要手动去配置.

//按住Ctrl点击查看启动类MySpringBootApplication上的注解@SpringBootApplication
@SpringBootApplication  //声明该类是一个spring引导类
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class);
    }
----------------------------------------------------------------------
//注解@SpringBootApplication的原码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration  //等同于@Configuration,即标注该类是spring的一个配置类
@EnableAutoConfiguration  //就是SpringBoot进行自动配置的一个核心注解
@ComponentScan(excludeFilters = {//组件扫描,会扫描到同级,以及子包下的文件
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
//...............
}
----------------------------------------------------------------------
//按住Ctrl点击@SpringBootConfiguration注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration  //该注解作用就是标注该类是spring的一个配置类
public @interface SpringBootConfiguration {
}
----------------------------------------------------------------------
//按住Ctrl点击查看@EnableAutoConfiguration注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class) //当前的配置文件引入其他的配置类,AutoConfigurationImportSelector:自动配置的导入选择器
public @interface EnableAutoConfiguration {
//..........
}

4. SpringBoot配置文件

 4.1 SpringBoot配置文件类型

  4.1.1 SpringBoot配置文件类型和作用

SpringBoot是基于约定的,所以有很多配置都有默认值,我们可以使用application.properties或者application.yml进行配置.SpringBoot默认会从resource目录下加载application.properties或者application.yml文件.

  4.1.2 application.yml配置文件

YML文件的扩展名可以使用.yml或者.yaml
注意:每一个之前面都会有一个空格(冒号后面)
yml配置文件的语法:
(1)配置普通数据

• 语法: key: value
• 示例代码:

name: laowang

注意:value之前有一个空格.
(2)配置对象或者Map数据

• 语法:
  key:
  key1: value1
  key2: value2
  或者:
  key: {key1: value1,key2: value2}
• 示例代码:

person:
  name: laowang
  age: 25
  addr: nicai
#或者
person: {name: laowang,age: 25,addr: nicai}

注意:key1前面的空格个数不限定,在yml语法中,相同缩进代表同一个级别.
(3)配置数组(List,Set)数据

• 语法:
  key:
  – value1
  – value2
  或者:
  key: [value1,value2]
• 示例代码:

city:
  - henan
  - fujian
  - dongguan
  - nanjing
#或者
city: [henan,fujain,dongguan,nanjing]
#集合中的元素是对象形式
student:
  - name: laowang
    age: 25
    score: 10
  - name: laoliu
    age: 24
    score: 100

注意:value1与之间的 - 之间存在一个空格

  4.1.3 SpringBoot配置信息的查询

SpringBoot的官方文档:
https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/#common-applicationproperties
常用的配置:

# QUARTZ SCHEDULER (QuartzProperties)
spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.
sql # Path to the SQL file to use to initialize the database schema.

spring.quartz.job-store-type=memory # Quartz job store type.
spring.quartz.properties.*= # Additional Quartz Scheduler properties.

# ----------------------------------------
# WEB PROPERTIES
# ----------------------------------------
# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080 # Server HTTP port.
server.servlet.context-path= # Context path of the application.
server.servlet.path=/ # Path of the main dispatcher servlet.

# HTTP encoding (HttpEncodingProperties)
spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to
the "Content-Type" header if not set explicitly.

# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date format
class name. For instance, `yyyy-MM-dd HH:mm:ss`.

# SPRING MVC (WebMvcProperties)
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher
servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Autodetected based on the URL by default.
spring.datasource.password= # Login password of the database.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.

# JEST (Elasticsearch HTTP client) (JestProperties)
spring.elasticsearch.jest.password= # Login password.
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use.
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use.
spring.elasticsearch.jest.read-timeout=3s # Read timeout.
spring.elasticsearch.jest.username= # Login username.

我们可以通过application.properties或者application.yml文件来修改SpringBoot的默认配置
例如:
application.properties文件

server.port=8888
server.servlet.context-path=/demo

application.yml文件

server:
  port: 8888
  servlet:
    context-path: /demo

 4.2 配置文件与配置类的属性映射方式

  4.2.1 使用注解@Value映射

application.yml配置如下:

student:
  name: laowang
  age: 18

实体bean代码如下:

@Controller
public class TestController {

    @Value("${student.name}")
    private String name;
    @Value("${student.age}")
    private Integer age;

    @RequestMapping("/test")
    @ResponseBody
    public String testMethod(){
        return name+"=="+age;
    }
}

  4.2.2 使用注解@ConfigurationProperties映射

application.yml配置如下:

student:
  name: laowang
  age: 18

实体bean代码如下:

@Controller
@ConfigurationProperties(prefix = "student")
public class TestController1 {

    private String name;
    private Integer age;

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

    @RequestMapping("/test1")
    @ResponseBody
    public String testMethod(){
        return name+"++"+age;
    }
}

注意:使用@ConfigurationProperties注解进行配置文件与实体字段的自动映射时,需要给字段提供set方法才可以,而使用@Value注解时则不需要.

5. SpringBoot整合其他技术

 5.1 SpringBoot整合MyBatis

1. 添加MyBatis的起步依赖

		<dependency>
			<groupId>org.mybatis.spring.bootgroupId>
			<artifactId>mybatis-spring-boot-starterartifactId>
			<version>1.1.1version>
		dependency>

2. 添加数据库驱动坐标

		<dependency>
			<groupId>mysqlgroupId>
			<artifactId>mysql-connector-javaartifactId>
		dependency>

3. 添加数据库连接信息
在application.properties文件中添加数据库的连接信息
服务信息默认端口为8080,path为/,如果需要可以进行修改配置,如果不需要可以不写.

# 服务信息
server.port=8888
server.servlet.context-path=/springboot_idea

# 数据库连接信息
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#这个可能会报时区错误,可以选用下面那个配置
#spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=123456

4. 创建user表

-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`username` VARCHAR(50) DEFAULT NULL,
`password` VARCHAR(50) DEFAULT NULL,
`name` VARCHAR(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'laowang', '123', '老王');
INSERT INTO `user` VALUES ('2', 'laoliu', '123', '老刘');

5. 创建实体Bean

public class User implements Serializable{
    private Long id;
    private String userName;
    private String password;
    private String name;
    //此处省略getter和setter方法
    }

6. 编写Mapper

@Mapper
public interface UserMapper {
    List<User> findUserList();
}

7. 配置Mapper映射文件
在src/resources/mapper路径下加入UserMapper.xml配置文件

<mapper namespace="com.laowang.springboot_idea.mapper.UserMapper">
    <select id="findUserList" resultType="user">
        select * from user
    select>
mapper>

8. 在application.properties文件中添加mybatis的信息

#spring集成MyBatis环境
#pojo别名扫描包
mybatis.type-aliases-package=com.laowang.springboot_idea.model
#加载mybatis映射文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml

9. 编写测试Controller

@Controller
public class UserController {
    @Autowired
    private UserMapper userMapper;
    @RequestMapping("/findUserList")
    @ResponseBody
    public List<User> findUserList(){
        List<User> users = userMapper.findUserList();
        return users;
    }
}

10. 测试

 5.2 SpringBoot整合Junit

1. 添加Junit的起步依赖

		
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-testartifactId>
			<scope>testscope>
		dependency>

2. 编写测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootIdeaApplicationTests {
	@Autowired
	private UserMapper userMapper;
	@Test
	public void test() {
        List<User> users = userMapper.findUserList();
        System.out.println(users);
    }
}

3. 测试
   

 5.3 SpringBoot整合Spring Data JPA

1. 添加Spring Data JPA的起步依赖

		
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-data-jpaartifactId>
		dependency>

2. 添加数据库驱动依赖

!-- MySQL连接驱动 -->
		<dependency>
			<groupId>mysqlgroupId>
			<artifactId>mysql-connector-javaartifactId>
		dependency>

3. 在application.properties中配置数据库和JPA的相关属性

# 数据库连接信息
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

#JPA相关信息
spring.jpa.database=MySQL
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy

4. 创建实体Bean

@Entity
public class User implements Serializable{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String userName;
    private String password;
    private String name;
    //此处省略getter和setter方法
    }

5. 编写UserRepository

public interface UserRepository extends JpaRepository<User,Long>{
    List<User> findAll();
}

6. 编写测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootIdeaApplicationTests {
	@Autowired
	private UserRepository userRepository;
	@Test
	public void test() {
        List<User> users = userRepository.findAll();
        System.out.println(users);
    }
}

 5.4 SpringBoot整合Redis

1. 添加Redis的起步依赖

		
		<dependency>
			<groupId>org.springframework.bootgroupId>
			<artifactId>spring-boot-starter-data-redisartifactId>
		dependency>

2. application.properties中配置Redis的连接信息

#Redis连接信息
spring.redis.host=localhost
spring.redis.port=6379

3. 注入RedisTemplate测试Redis操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {
	@Autowired
	private UserRepository userRepository;
	@Autowired
	private RedisTemplate<String,String> redisTemplate;
	@Test
	public void test() throws JsonProcessingException {
		//从Redis缓存中取指定的数据
		String userList = redisTemplate.boundValueOps("user.findAll").get();
		//如果Redis中没有数据的话
		if (userList==null){
			//查询数据库获得数据
			List<User> users = userRepository.findAll();
			//转换成json格式字符串
			ObjectMapper om = new ObjectMapper();
			 userList = om.writeValueAsString(users);
			 //将查询到的数据放到Redis缓存中
			redisTemplate.boundValueOps("user.findAll").set(userList);
			System.out.println("======从数据库获得数据======");
		}else{
			System.out.println("======从Redis缓存中获得数据======");
		}
        System.out.println(userList);
    }
}