Spring Boot 的第一次使用

最新推荐文章于 2024-06-24 15:42:47 发布

fantenglong_Java

最新推荐文章于 2024-06-24 15:42:47 发布

阅读量224

点赞数

分类专栏： java 文章标签： spring boot

本文链接：https://blog.csdn.net/fantenglong_Java/article/details/88327149

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring Boot 特性

创建独立的Spring应用程序
嵌入的Tomcat，无需部署WAR文件
简化Maven配置
自动配置Spring
提供生产就绪型功能，如嵌入式服务器，指标，健康检查和外部配置
开箱即用，没有代码生产，也不需XML配置。

新建一个java项目 Spring-Boot-Hello（maven）

引入spring boot 的修改 pom.xml 文件

    <!-- 
spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。
 -->
    <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>1.4.1.RELEASE</version>
    </parent>
  
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 指定jdk版本1.8， 默认是1.6 -->
    <java.version>1.8</java.version>
  </properties>
  
  <dependencies>
     <!-- 添加spring-boot-starter-web依赖 提供了 MVC、AOP的依赖包等。。。 -->
    <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
  </dependencies>

新建一个controller

@RestController  // 这个注解等价于 @Controller 和 @RequestBody
public class HelloContoller {

    @RequestMapping("/hello") // 使用这个注解是建立请求映射http://localhost:8080/hello
    public String hello(){
         return "hello";
    }
}

修改启动类 App.java

@SpringBootApplication // 使用这个注解 指定这个是springboot的应用程序
public class App 
{
    public static void main( String[] args )
    {
     // 启动程序
     SpringApplication.run(App.class, args);
        //System.out.println( "Hello World!" );
    }
}

进行访问测试端口号是8080（默认）

Spring boot 返回一个json数据

新建一个测试实体类 demo

添加映射方法 getDemo();

// Spring Boot 默认使用的json解析框架是jackson
@RequestMapping("/getDemo")
public Demo getDemo(){
    Demo demo = new Demo();
    demo.setId(1);
    demo.setName("张三");
    demo.setAge(20);
    return demo;
}

测试访问地址： http://localhost:8080/getDemo

结果：

Spring Boot 完美使用 FastJson 解析 json 数据

添加fastjson依赖包

<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.15</version>
</dependency>

配置fastjson（支持两种方法）

第一种方法
1. 启动类继承 WebMvcConfigurerAdapter
2. 重载方法 configureMessageConverters

@SpringBootApplication // 使用这个注解 指定这个是 springboot 的应用程序

public class App extends WebMvcConfigurerAdapter

{
    @Override
    public void configureMessageConverters(
             List<HttpMessageConverter<?>> 
converters) {
         super.configureMessageConverters(converters);
// 1. 需要先定义一个 convert 转换消息的对象；
         FastJsonHttpMessageConverter fastConverter 
= new FastJsonHttpMessageConverter();
// 2. 添加fastJson 的配置信息，比如： 是否要格式换返回json数据；
            FastJsonConfig fastJsonConfig = new 
FastJsonConfig();
            fastJsonConfig.setSerializerFeatures(
                    SerializerFeature.PrettyFormat
            );
// 3. 在 convent 中添加配置信息；       
fastConverter.setFastJsonConfig(fastJsonConfig);
// 4、将 convent 添加到 converters 当中
 converters.add(fastConverter);
    }
    public static void main( String[] args )
    {
     // 启动程序
     SpringApplication.run(App.class, args);
        //System.out.println( "Hello World!" );
    }
}

第二种方法
在 App.java 启动类中注入Bean： HttpMessageConverters

总结：
我们要使用第三方的json解析框架的时候：
1.我们需要在pom.xml中引入相应的依赖；
2.需要在App.java中继承WebMvcConfigurerAdapter重写方法configureMessageConverters 添加我们自己定义的json解析框架;
2.1 @Bean注入第三方的json解析框架：

@Bean
	public HttpMessageConverters fastJsonHttpMessageConverters() {
        // 1.需要先定义一个 convert 转换消息的对象；
		FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        // 2. 添加fastJson 的配置信息，比如： 是否要格式换返回json数据；
		FastJsonConfig fastJsonConfig = new FastJsonConfig();
		fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        
        // 解决中文乱码的问题
        List<MediaType> fastMediaTypes = new ArrayList<>();
        fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        fastConverter.setSupportedMediaTypes(fastMediaTypes);
        // 3. 在 convent 中添加配置信息；     
		fastConverter.setFastJsonConfig(fastJsonConfig);
        // 4、将 convent 添加到 converters 当中
		HttpMessageConverter<?> converter = fastConverter;
		return new HttpMessageConverters(converter);
	}

上面的代码中有解决 FastJson 的中文乱码问题的方法。

fastjson的几个常见功能

日期时间格式化 @JSONField(format="yyyy-MM-dd HH-mm")
返回值隐藏某字段 serialize:是否需要序列化属性. @JSONField(serialize=false)

Spring Boot 的热部署

所谓热部署，就是在应用正在运行的时候升级软件，却不需要重新启动应用。
** 使用 springloader 热部署

导入 spring loader 的依赖

** 使用 spring-boot-devtools 热部署

深层原理使用了两个ClassLoader , 一个 Classloader 加载那些不会改变的类（第三方jar包），另一个Classloader 加载会更改的类，称为 restart ClassLoader。
这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）。

添加依赖包：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
           <scope>true</scope>
</dependency>

添加spring-boot-maven-plugin:

<build>
		<plugins>
		    <plugin>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-maven-plugin</artifactId>
	            <configuration>
	          		<!--fork :  如果没有该项配置，肯呢个devtools不会起作用，即应用不会restart -->
	                <fork>true</fork>
	            </configuration>
	        </plugin>
		</plugins>
   </build>

说明

devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存 Ctrl+s 时），注意：因为其采用的虚拟机机制，该项重启是很快的。
devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样)。

测试方法
修改类–>保存：应用会重启
修改配置文件–>保存：应用会重启
修改页面–>保存：应用会重启，页面会刷新（原理是将spring.thymeleaf.cache设为false）

Spring Boot JPA/Hibernate/Spring Data 概念

JPA(Java Persistence API) 是SUN官方提出的java持久化规范。他为java开发人员提供了一种对象/关系映射工具来管理java应用中的关系数据。
持久化是将程序数据在持久状态和瞬时状态间转换的机制。
JDBC就是一种持久化机制。

Hibernate

JPA 是一种规范， Hibernate 是它的一种是实现。

orm

Spring Data

一个用于简化数据库访问 ，并支持云服务的开元框架。

Spring Data JPA-Hibernate

在pom.xml添加mysql，spring-data-jpa依赖；

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

在application.properties 文件中设置mysql连接配置文件；

########################################################
### datasource
########################################################
spring.datasource.url = jdbc:mysql://<u>localhost</u>:3306/test
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

在application.properties 文件中配置JPA配置信息；

########################################################
### Java Persistence Api
########################################################
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each <u>sql</u> query
spring.jpa.show-sql = true
# <u>Hibernate</u> <u>ddl</u> auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
#[org.hibernate.cfg.ImprovedNamingStrategy #org.hibernate.cfg.DefaultNamingStrategy]
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

编写测试例子
1. 创建一个实体类如何持久化呢？
  1. 使用@Entity进行实体类的持久化操作，当JPA检测到我们的实体类当中有 @Entity 注解的时候，会在数据库中生成对应的表结构信息。
  2. 如何指定主键以及主键的生成策略？
    使用 @Id 指定主键。
    使用 @GeneratedValue(strategy=GenerationType.AUTO) 指定主键的生成策略，mysql默认的是自增长。

@Entity
public class Cat {
	@Id @GeneratedValue(strategy=GenerationType.AUTO)
	private int id;	// 主键
	private String catName;
	private int catAge;
	private String sex;

2. 创建jpa repository类操作持久化(CrudRepository)。

public interface CatRepository extends CrudRepository<Cat, Integer>{
}

3. 创建一个Service

@Service
public class CatService {
      @Resource
      private CatRepository catRepository; 
      /**
       * save updte delete 方法需要绑定事务
       * 使用 @Transactional 进行事务的绑定
       */
      // 保存数据
      @Transactional
      public void save(Cat cat) {
            catRepository.save(cat);
      }
      // 删除数据
      @Transactional
      public void delete(int id){
            catRepository.delete(id);
      }
      // 查询数据
      @Transactional
      public Iterable<Cat> getAll(){
            return catRepository.findAll();
      } 
}

4. 创建一个Controller,创建请求方法。

@RestController
@RequestMapping("/cat")
public class CatController {
	@Resource
	private CatService catService;
	@RequestMapping("/save")
	public String save(){
		Cat cat = new Cat();
		cat.setCatName("jack");
		cat.setCatAge(2);
		cat.setSex("母");
		catService.save(cat);
		return "save Ok";
	}	
	@RequestMapping("/delete")
	public String delete(){
		catService.delete(1);
		return "delete Ok";
	}
	@RequestMapping("/getAll")
	public Iterable<Cat> getAll(){
		return catService.getAll();
	}
}

5. 代码测试
访问 http://localhost:8080/cat/save
访问 http://localhost:8080/cat/save
访问 http://localhost:8080/cat/save
访问 http://localhost:8080/cat/delete
访问 http://localhost:8080/cat/getAll

Spring Boot Spring Data JPA 介绍

Repository 接口

Repository 是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口声明需要的方法：

public interface Repository<T,ID extends Serializable>{}

Repository是一个空接口，既是一个标记接口；
我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。
也可以通过 @RepositoryDefinition注解来替代继承Repository接口；
查询方法以 find|read|get开头；
涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写；
使用@Query注解可以自定义JPQL语句实现更灵活的查询。