SpringBoot

最新推荐文章于 2023-05-16 11:25:36 发布

赚钱养廷廷

最新推荐文章于 2023-05-16 11:25:36 发布

阅读量241

点赞数

分类专栏：总结文章标签：学习总结

本文链接：https://blog.csdn.net/J2015330214/article/details/83019449

版权

总结专栏收录该内容

5 篇文章 0 订阅

订阅专栏

概念

基于spring框架快速搭建的一个工具。

核心功能

独立运行：只需要具备运行的环境jdk和main（）的入口就可以了，不需要外部支持spring框架的容器。
内嵌的servlet容器：web应用不需要依靠外部的web容器，也就是不用配置web.xml，直接启动springboot就可以完成一个web应用的运行（独立运行spring+springmvc项目），默认的是tomcat容器，也可以替换成其他容器jetty,underlow
简化maven依赖：maven依赖具有传递性。如果使用springboot搭建一个web应用，只需要依赖spring-boot-starter-web
自动配置spring：尽可能的0xml配置文件,注解会完成所有的内容

核心原理

@SpringBootApplication注解—组合注解
组合了以下三个注解：
@SpringBootConfiguration—提供0配置，必须配置springBoot的配置文件application.properties,bootstrap.properties等满足springboot的配置文件。
@EnableAutoConfiguration—开启自动配置的注解。根据依赖的jar包，自动检测需要配置的所有的springboot工程的默认内容。例如：依赖starter-web,会自动配置端口号和默认路径。Starter-amqp自动配置需要注入的对象rabbitTemplate对象。
@ComponentScan—对象扫描器。会自动扫描当前工程与启动类同名、下级包中的所有spring+springmvc的注解，然后创建对象。
利用注解底层的实现原理是：反射+注解

搭建springboot

快速搭建

	利用网站的工具搭建一个简化的springboot工程---[http://start.spring.io/](http://start.spring.io/)

手动搭建

以搭建一个java工程(quickstart)为例:

常见一个quickstart的maven工程
修改pom.xml文件：添加springboot的父级依赖

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
</parent>
<!--编码配置-->
 <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
</properties>

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

编写springboot启动类

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

}

当前的springboot依赖的starter-web简化dependency，说明需要当前工程开发成ss框架的web应用，所以根据自动配置原理，内嵌的servlet容器起作用，就自动配置到习惯的8080端口并且路径是/‘

全局配置

可以加载一个application的全局配置文件，以key-value的形式来配置我们需要的内容，例如端口号，默认的工程访问路径/，页面解析的前缀和后缀等。
application的全局配置文件有两种类型：

properties：key-value形式
yml：application的文本格式，本质上还是properties，只不过是以一种面向数据为核心的结构展示出来了，这样前缀相同的key就不需要多次重复的拼接了。
如何默认的配置端口号和访问路径？
application.properties类型：
service.port=8090
service.context-path=/haha
yml类型：
service:
[空格]port:[空格]8090
[空格]context-path:[空格]/haha

练习：properties类型转换为yml类型

properties结构

spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
spring.datasource.druid.test-on-borrow=true

yml格式：

spring:
[]datasource:
[][]druid:
[][][]initial-size:[]1
[][][]min-idle:[]1
[][][]max-active:[]20
[][][]test-on-borrow:[]true

额外配置

springboot的自动配置十分方便，但是不可能考虑到所有的开发环境。所以常常需要额外的引入xml的配置。
案例：
利用xml配置文件，加载bean标签，创建启动类无法扫描的service注解

package xx.yy;
import org.springframework.stereotype.Service;

@Service
public class HelloService {
	
	public String say(String name){
		return "嘻嘻:"+name;
	}

}

applicationContext.xml配置文件中的配置：

<bean id="helloService" class="cn.tedu.HelloService"></bean>

启动类所在包下的配置类：

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class ConfigurationTest {

}

注意：
@Configuration：加载额外的配置文件
@ImportResource(“classpath:applicationContext.xml”)：引入配置文件

属性读取

编写一个需要读取配置文件属性的Component类

@Component
public class Student {
	
	@Value("${name}")
	private String name;
	@Value("${age}")
	private Integer age;
	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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}

在controller中注入使用，访问测试方法，查看返回的student数据是否正确
这里经过ResponseBody注解，将返回的数据直接放到响应体，对象student会被翻译成json字符
串

	@Autowired
	private Student student;
	@RequestMapping("student")
	@ResponseBody
	public Student toStudent(){
		return student;
	}

在配置文件中配置

name=haha
age=18

一般我们使用@Configration+@Value将需要的springboot无法读取的配置内容读到当前的类中，然后利用类中的方法，使用私有属性创建一些技术的链接对象，然后+@Bean的方法注解，实现这些链接对象的创建工作；

JPA

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
也就是它可以实现通用持久层的逻辑，不用再自己编写sql，在jpa，通用持久层的sql会自动的拼接（使用注解），从而进行表与类，属性与字段的对应关系。
@Table（name=“表名”）实现类与表格的对应，如果表名与类名一致，那么就不需要用该注解
@Column（name=“列名”）实现的是属性与列的对应关系，如果满足驼峰命名，无需使用
@Id 表示当前属性在数据库中是主键
@GeneratedValue 定义逐渐的生成策略（auto_increment自增）

SpringBoot与JPA持久层整合

添加依赖

<dependency>
  			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
  	</dependency>
  	<dependency>
  			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
  	</dependency>

相关配置文件application.properties

#datasource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql:///springboot
spring.datasource.username=root
spring.datasource.password=root

#jpa
spring.jpa.hibernate.ddl.auto=update

注意：jpa底层操作数据库表格，每次操作都会默认重建。也就是在每次操作前执行create操作，在创建前会先把表格drop掉，所以一定要写这句，避免重建。
3. 创建相应的数据库表格
4. 利用持久层表格获取数据–需要有一个对应的pojo类

@Entity
public class User {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;
	private String name;
	private Integer age;

注意：@Entity使用的包是import javax.persistence.Entity；这是jpa的注解

编写持久层的接口继承JpaRepository
jpa当中的所有通用方法，都是同一个接口完成的，要想实现某一个pojo的通用方法的调用，必须定义一个具有当前pojo反射的子接口

public interface UserDao extends JpaRepository<User, Integer>{

}

User表示当前dao接口操作的pojo类，通过这个泛型的反射技术，获取User的table注解，id注解，GeneratedValue等注解，其实是在底层将sql与注解进行拼接。这样，调用当前接口的方法，可以实现user表格单表的增删改查，无需sql语句的编写；
6. 测试利用jpa持久层对tb_user表格增删改查

@Controller
public class UserController {

	@Autowired
	private UserService userService;
	@RequestMapping("findAllUser")
	@ResponseBody
	public List<User> findAllUser(){
		return userService.findAllUser();
	}	
}

@Service
public class UserService {

	@Autowired
	private UserDao userDao;
	
	public List<User> findAllUser(){
		List<User> list = userDao.findAll();
		return list;
	}
}

JPA通用持久层的调用原理：
在不编写任何sql语句的情况下，直接调用通用的方法，实现单表的增删改查。Dao类中包含一个pojo的泛型，底层代理实现接口方法时，可以通过泛型pojo获取pojo的所有信息包括Table注解和其中的name属性值，从而将sql与注解表明进行拼接。

SpringBoot与mybatis持久层整合

添加mybatis依赖

<dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.0</version>
    </dependency>

配置文件

#mybatis
mybatis.typeAliasesPackage=com.jt.pojo
mybatis.mapperLocations=classpath:mappers/*.xml
mybatis.configuration.mapUndersoreToCamekCase=true

mapper.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.jt.mapper.UserMapper">

	<select id="findAll" resultType="User">
		select * from user;
	</select>
</mapper>

UserMapper，UserService，UserController类编写与框架一样
在启动类添加mapper扫描器

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

框架管理mapper对象就是通过MapperScan注解来完成，相当于spring整合mybatis时在配置文件中需要添加mapper类的扫描一样。

springboot的jsp页面

springboot工程，在内嵌的servlet容器中无法直接使用jsp，有冲突；可以通过引擎模板来完成jsp的内嵌容器显示；也可以利用maven的webapp骨架实现jsp的页面解析和显示，springboot的工程中没有默认的首页访问（web.xml）

使用maven的webapp骨架搭建一个项目
添加相关依赖

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
  </parent>
  <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
  </properties>
........
 <dependencies>
  	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	
	<!--servlet依赖 -->
		<dependency>
    		<groupId>javax.servlet</groupId>
   			<artifactId>javax.servlet-api</artifactId>
    		<version>3.1.0</version>
    		<scope>provided</scope>
		</dependency>

		<!--jstl依赖 -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>

		<!--使jsp页面生效 -->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
  </dependencies>

配置jsp前缀和后缀

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

编写启动类

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

发布

springboot发布可以使用两个方式：

在jdk环境下运行war包，不需要第三方的web容器
添加一个maven的打包插件

 <build>
  <!--当前工程打包后的名称，是通过filename指定，如果没有fileName默认使用工程名称  -->
  	<finalName>springboot</finalName>
  	<plugins>
  		<plugin>
  			<!-- springboot 整合maven的插件 -->
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-maven-plugin</artifactId>
  		</plugin>
  	</plugins>
  </build>

在第三方web容器下
注意：
当前工程编译的jdk版本（这与eclipse当前工程的jdk有关）与运行的系统中的jdk，版本不一致，很可能导致出现运行时出现异常。
去除第三方的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>

准备一个tomcat9的软件
由于springboot内嵌servlet容器默认的tomcat版本是8.5，所以外部容器必须支持8.5以上，这里使用tomcat9
扩展：
安装tomcat9，运行提示：catalina_home没有设置
原因有两方面：当前jdk环境没有配置java_home，或者jdk版本不是1.8以上
为tomcat准备一个入口类，用于指向启动类的main方法

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

public class SpringBootForTomcat extends SpringBootServletInitializer{

		@Override
		protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
			return builder.sources(Start01.class);
		}
	
}