您的位置：首页 > 编程语言 > Java开发

2小时学会Spring Boot 学习笔记

2017-10-28 01:06 459 查看

前言

Spring Boot
是用来简化
Spring
应用初始搭建以及开发过程的全新框架，被认为是
SpringMVC
的接班人，和微服务紧密联系在一起。Spring Boot 简单实例Demo

SpringMVC 的优缺点

优点：

Spring Boot
适合快速开发，适合构建微服务系统。封装了经常使用的组件，比如
MyBatis
, 
Hibernate
, 
MongoDB
等。

纯
Java
的配置，简单方便。

配置Maven等构建工具后，
java -jar
进行部署比较简单。

Spring Boot
对自定义十分友好，可以配置在
application.yml
或者
Config
类，
Spring Boot
的整体思想是有自定义的话，自定义优先，否则走默认配置。

Spring Boot
使编码，配置，部署，监控变得简单起来。

缺点：

太方便，使得没有经验的新手根本不知道
Spring Boot
底层到底干了什么。集成度较高，使用过程中不容易了解底层。

相关学习文档少， 坑多。

第一个Spring Boot的应用

首先创建一个
New Project
，要选择
Spring Initializr,
然后
Choose Initializr Service URL
应该选择
Custom
, 正确的链接应该是
http://start.spring.io/
，而不是
https://start.spring.io/
。
https
会造成我们访问失败!



2.相关配置，
Type
我们选择
Maven Project




3.选择
Web
就行了。另外
Spring Boot
的版本是1.5.8



4.
Finished
。大功告成!



5.由于默认的
setting.xml
配置，导致我们从远程下jar实在是太慢，所以我们要修改
.m2
下面的
setting.xml
文件，同时将
setting.xml
原本指向
C:\Users\Administrator\.m2\repository
的仓库地址，改成我们自定义的盘下面即可。

我的setting.xml是这样的，如果还是看不懂的话，请移步Setting.xml相关配置

<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors


6.我们可以看到这个
DemoApplication
类， 这是整个
Spring Boot
应用的入口，有
@SpringBootApplication
这个注解，显而易见。

@SpringBootApplication
public class DemoApplication {

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


7.接下来我们创建一个
HelloController.java
, 
@RestController
这个注解的作用：声明这是一个
Controller
类，返回
json
。其实就是
@ResponseBody
和
@Controller
的结合体。

@RestController
public class HelloController {

@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String say() {
return "Hello, Spring Boot!";
}
}


8.启动有3种方式。

（1）直接在
Itellij IDEA
启动。



（2）在项目的根目录下，打开命令窗口，输入
mvn spring-boot:run




(3)在项目的根目录下，打开命令窗口，输入
mvn install
,让项目生成
jar
包。



然后会发现
target
包下面多了一个
jar
包。



输入命令
java -jar target/demo-0.0.1-SNAPSHOT.jar




9.我们就可以访问
Spring Boot
应用了。



项目属性配置

1.我们可以在
resources文件夹
下面建3个
properties
， 
application-dev.properties
是开发环境下的配置文件。
application-prod.properties
是应用环境下的配置文件。
Spring Boot
默认读取的配置文件是
application.properties
,我们只需要在
application.properties
指定使用哪一个环境下的配置文件即可。比如:
spring.profiles.active=dev




2.我们在
application-dev.properties
，配置一些信息，让我们的
Controller
类去读取配置信息。

server.port=8081
server.context-path=/girl
cupSize=A
height=160
content="cupSize: ${cupSize}, age: ${height}"
girl.cupSize=A
girl.height=160


3.Controller类读取配置信息，启动Spring Boot输出结果。

public class HelloController {
@Value("${cupSize}")
private String cupSize;

@Value("${height}")
private String height;

@Value("${content}")
private String content;

@RequestMapping(value = "/display", method = RequestMethod.GET)
public String display() {
return "cupSize=" + cupSize + ", height=" + height;
}

@RequestMapping(value = "/content", method = RequestMethod.GET)
public String displayContent() {
return content;
}
}






4.
Controller
类读取配置信息带前缀的字符串，比如我们要读取
girl.cupSize=A girl.height=160
这些带girl的配置信息，我们该怎么办呢。我们需要定义一个
GirlProperties.java
。
@ConfigurationProperties
代表我们要读取带什么前缀的配置信息，
@Component
代表这个类已经在Spring配置文件中注册过。

@ConfigurationProperties(prefix = "girl")
@Component
public class GirlProperties {
private String cupSize;
private String height;

public String getCupSize() {
return cupSize;
}

public void setCupSize(String cupSize) {
this.cupSize = cupSize;
}

public String getHeight() {
return height;
}

public void setHeight(String height) {
this.height = height;
}
}


5.
Controller
类读取
GirlProperties
，我们要使用
@Autowired
注入
GirlProperties
这个类的实例，它是通过bean的类型注入的。启动Spring Boot应用，输出结果。

@RestController
public class HelloController {
@Autowired
private GirlProperties girlProperties;

@RequestMapping(value = "/properties", method = RequestMethod.GET)
public String displayProperties() {
return girlProperties.getCupSize() + girlProperties.getHeight();
}
}




Controller的使用

1.尽量使用
@GetMapping
和 
@PostMapping
代替 
@RequestMapping(value = "/xxxxx", method = RequestMethod.GET)


2.如果需要在
Spring Boot
使用
@Controller
，需要返回一个逻辑视图。比如

@Controller
public class DemoController {
@RequestMapping(value = "/saylove", method = RequestMethod.GET)
public String sayLove() {
return "index";
}
}


index.html
是在
templates
文件夹下面的



3.
pom.xml
配置如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>

<groupId>girl</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>demo</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.8.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>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test&l
ed51
t;/artifactId>
<scope>test</scope>
</dependency>

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

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>1.5.8.RELEASE</version>
</dependency>

</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>


数据库操作

1.在
application-dev.properties
配置数据连接配置

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/spring_boot
spring.datasource.username=root
spring.datasource.password=xiaoma96
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true


spring.jpa.hibernate.ddl-auto
有4个属性：

create
： 不管数据库原先有没有这个表，每次启动应用，都会drop这个表，然后再创建新的一张表。

update
: 如果数据库中有这个表且有数据，那么我会保留这张表，不会去删除它。

create-drop
: 应用停止的时候， 会把数据库里面这张表删除。

none
: 不产生任何行为。

2.什么是
JPA
？
JPA
的英文全称是
Java Persistence API
定义了一系列对象持久化的标准，目前实现这个规范的产品有
Hibernate
。

3.怎么去使用
JPA
? 之前用过
Liferay
技术， 
Liferay
通过
ServiceBuilder
生成
Service.xml
，在这个
Service.xml
配置你需要创建数据库表的
entity
信息，然后定义一些方法的字段。然后build一下。就会生成对应的
CRUD
方法，很是智能。而且在下一次应用启动时，会生成对应的数据库表哟。如果需要定制化sql语句，只需要在
finderImpl
和
ServiceImpl
里面添加自己的方法，然后
build
一下，重新生成接口。同样
JPA
，简单的
CRUD
我们不需要去写sql语句，只需要定义一个
GirlRepository
的接口，继承
JpaRepository<Girl, Integer>
就行了。需要定制化
CRUD
，我们添加相应的方法就行了。

public interface GirlRepository extends JpaRepository<Girl, Integer> {

public List<Girl> findByAge(Integer age);

public List<Girl> findByCupSize(String cupSize);

public List<Girl> findByName(String name);
}


4.定义
RESTfulAPI
，开放
CRUD
接口。增加，使用
POST
， 查询使用
GET
， 更新使用
PUT
，删除使用
DELETE
。

@RestController
public class GirlController {
@Autowired
private GirlRepository girlRepository;

/**
* Queries all girls.
* @return girls List queryed
*/
@GetMapping(value = "/girls")
public List<Girl> girlList() {
return girlRepository.findAll();
}

/**
* Adds girl
* @param name
* @param cupSize
* @param age
* @return girl added
*/
@PostMapping(value = "/girls")
public Girl girlAdd(@RequestParam("name") String name, @RequestParam("cupsize") String cupSize
, @RequestParam("age") Integer age) {
Girl girl = new Girl();
girl.setAge(age);
girl.setName(name);
girl.setCupSize(cupSize);
return girlRepository.save(girl);
}

/**
* Finds girl by id
* @param id
* @return girl finded
*/
@GetMapping(value = "/girls/{id}")
public Girl girlFindOne(@PathVariable("id") Integer id) {
return girlRepository.findOne(id);
}

/**
* Updates girl
* @param id
* @param name
* @param cupSize
* @param age
* @return girl updated
*/
@PutMapping(value = "/girls/{id}")
public Girl girlUpdateOne(@PathVariable("id") Integer id, @RequestParam("name") String name, @RequestParam("cupsize") String cupSize
, @RequestParam("age") Integer age) {
Girl girl = new Girl();
girl.setCupSize(cupSize);
girl.setName(name);
girl.setAge(age);
girl.setId(id);
return girlRepository.save(girl);
}

/**
* Deletes girl by id
* @param id
*/
@DeleteMapping(value = "/girls/{id}")
public void girlDeleteOne(@PathVariable("id") Integer id) {
girlRepository.delete(id);
}

/**
* Queries girls by name
* @param name
* @return girl list queryed
*/
@GetMapping(value = "/girls/name/{name}")
public List<Girl> girlFindByName(@PathVariable("name") String name) {
return girlRepository.findByName(name);
}

/**
* Queries girls by age
* @param age
* @return girl list queryed
*/
@GetMapping(value = "/girls/age/{age}")
public List<Girl> girlFindByAge(@PathVariable("age") Integer age) {
return girlRepository.findByAge(age);
}

/**
* Queries girls by cupsize
* @param cupSize
* @return girl list queryed
*/
@GetMapping(value = "/girls/cupsize/{cupsize}")
public List<Girl> girlFindByCupSize(@PathVariable("cupsize") String cupSize) {
return girlRepository.findByCupSize(cupSize);
}
}


5.使用
Postman
软件，测试
API
。在这里，我就测试一个查询
api
，演示一下。



事务管理

1.什么是事务?事务是作为一个逻辑单元执行的一系列操作。它有4个特性

* 原子性:事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么全部失败。

* 一致性: 一旦事务完成，不管成功还是失败，系统必须确保它所建模的业务处于一致的状态，而不全是部分完成，或者是部分失败，在现实的数据不应有被破坏。

* 隔离性： 可能有许多事务会同时处理相同的数据， 因此每个事务都应该与其他事务隔离开，防止数据被破坏。

* 持久性： 一旦事务完成， 无论发生什么，系统发生错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来， 通常情况下，事务的记过被写到持久化存储器。

2.我们常用的几个事务：

* 
PROPAGATION_REQUIRED
: 如果存在一个事务，则支持当前的事务，如果没有则开启。

* 
PROPAGATION_SUPPORTS
: 如果存在一个事务，就支持当前事务， 如果没有事务，则以非事务执行。

* 
PROPAGATION_REQUIRES_NEW
: 启动一个新的事务，不依赖当前事务，当前事务挂起。

3.我们模拟一个事务的回滚，体现事务的原子性，第一个
save
操作不会出现问题，第二个
save
操作会抛出异常。但是不能部分成功，不能部分失败。这二个操作最终会被回滚。

@Service
public class GirlService {

@Autowired
private GirlRepository girlRepository;

@Transactional
public void insertTwo() {
Girl girlA = new Girl("garrett-test", 18, "Z");
girlRepository.save(girlA);

Girl girlB = new Girl("mayday-test", 21, "BBBBBBBB");
girlRepository.save(girlB);
}
}

@RestController
public class GirlController {
@Autowired
private GirlService girlService;

/**
* Tests transaction
*/
@GetMapping(value = "/transaction")
public void transactionTest() {
girlService.insertTwo();
}
}


4.启动应用，打开
Postman
，测试
API
。很显然，操作发生异常进行回滚，数据库未插入任何数据。



尾言

学无止境，一起共勉。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航