SpringBoot

这里写图片描述

SpringBoot 是 SpringMVC 的升级版，相对于编码、配置、部署和监控方面，会更加简单

微服务

微服务是一个新兴的软件架构，就是把一个大型的单个应用程序和服务拆分为数十个的支持微服务。一个微服务的策略可以让工作变得更为简便，它可扩展单个组件而不是整个的应用程序堆栈，从而满足服务等级协议。

Spring 为微服务提供了一整套的组件-SpringClound , SpirngBoot 就是该基础。

这里写图片描述

第一个SpringBoot程序

这里使用的开发软件是IntelliJ Idea，和Eclipse差不太多，界面更炫酷，功能更强大；Android Studio就是基于IntelliJ 开发的，我之前使用过Android Studio，它俩界面几乎一样。

IntelliJ Idea官网：http://www.jetbrains.com/idea/
配置好 maven, tomcat, jdk 就可以使用了

maven配置的中央仓库阿里云镜像

这个地址下载 jar 包的速度，谁用谁知道！

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>

使用`IDEA`创建SpringBoot项目

这里使用idea配置：

这里版本不要太高了1.4.2就可以了

这三个文件可以删掉

项目结构：

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>com.xf</groupId>
   <artifactId>hello</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

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

   <!--spring boot 父节点依赖，引入这个之后相关的引入就不需要添加version配置，spring boot 会自动选择最合适的版本进行添加-->
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.4.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>
      <!--spring-boot-starter-web  mvc，aop的依赖包-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

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


</project>

HelloController

package com.xf.hello;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController   //相当于@Controller和@ResponseBody
public class HelloController {

    @RequestMapping("/hello")  //建立请求映射 http://192.168.1.3:8080/hello
    public String hello(){

        return "hello";
    }
}

HelloApplication

package com.xf.hello;

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

@SpringBootApplication  //指定这是一个spring boot应用程序
public class HelloApplication {

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

然后直接在地址栏输入就能访问了

自定义属性配置

用到的是application.properties这个文件

spring-boot配置文件中context-path不起作用：
原因是更新后语句变成了server.servlet.context-path=/xf,所以要改为

server.port=8081
server.servlet.context-path=/xf

除了使用.properties格式的文件，还可以使用.yml格式的配置文件(推荐)，更加简便
application.yml

server:
    port: 8082
    servlet:
      context-path: /springboot

把原来的 application.properties 文件删除

注意格式，空格不能少

获取配置文件中的属性值

我们也可以在配置文件中，配置数据，在 Controller 中获取,比如：
application.yml

server:
    port: 8082
    servlet:
      context-path: /springboot
name: 阿飞

package com.xf.curdhibernate.Controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController //相当于@Controller和@ResponseBody
public class HelloController {

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

    @RequestMapping("/hello")
    public String say(){
        return name;
    }
}

配置文件中值配置方式的多样化

配置文件的值可以是多个，也可以是组合，如：

application.yml

server:
    port: 8082
    servlet:
      context-path: /springboot
name: 阿飞
age: 22

或者

application-a.yml

server:
    port: 8082
    servlet:
      context-path: /springboot
name: 阿飞
age: 22
content: "name: ${name},age: ${age}"

或者

application-b.yml

server:
    port: 8082
    servlet:
      context-path: /springboot
person:
  name: 阿飞
  age: 22

前两种配置获取值的方式都是一样的,但是对于这种方式，person 有相应的两个属性，需要这样处理

PersonProperties.java

package com.xf.curdhibernate;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix ="person")
public class PersonProperties {
    private String name;
    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;
    }
}

Alt+insert快捷键提示生成 Getter and Setter

pom.xml需要加入下面的依赖,处理警告

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-configuration-processor</artifactId>
   <optional>true</optional>
</dependency>

HelloController.java

package com.xf.curdhibernate.Controller;

import com.xf.curdhibernate.PersonProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController //相当于@Controller和@ResponseBody
public class HelloController {

    @Autowired
    private PersonProperties personProperties;



    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String say(){
        return personProperties.getName()+personProperties.getAge();
    }
}

关于配置文件`application.yml`的多套配置

类似 il8n 文件国际化的配置方式i18n_en_US.properties和i18n_zh_CN.properties
这样能解决，需要频繁修改配置的尴尬

由application.yml配置文件决定使用那套配置文件。

application.yml

spring:
  profiles:
    active: b

application-a.yml

server:
  port: 8081
  servlet:
    context-path: /springboot
person:
  name: 阿飞
  age: 21

application-b.yml

server:
  port: 8082
  servlet:
    context-path: /springboot
person:
  name: 小飞
  age: 22

SpringBoot增删改查实例

完整项目结构

Controller的使用

@Controller 出处理http请求

@RestController Spring4 之后新加的注解，原来返回json需要@ResponseBody配合@Controller

@RequestMapping 配置url映射

对于 Controller 中的方法上的注解

@RequestMapping(value = "/hello",method = RequestMethod.GET)
@RequestMapping(value = "/hello",method = RequestMethod.POST)
@RequestMapping(value = "/hello",method = RequestMethod.DELETE)
@RequestMapping(value = "/hello",method = RequestMethod.PUT)

SpringBoot 对上面的注解进行了简化

@GetMapping(value = "/girls")
@PostMapping(value = "/girls")
@PutMapping(value = "/girls/{id}")
@DeleteMapping(value = "/girls/{id}")

浏览器需要发送不同方式的请求，可以安装HttpRequester插件，火狐浏览器可以直接搜索该组件安装。

这里我用的是postman

spring-data-jpa

最近在学习Spring Data JPA的相关知识,感觉还是很不错的,提供了很多方法,包括CRUD和分页排序,基本能够满足现实的功能需求.

它一共提供了四个接口:

Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类，方便Spring自动扫描识别
CrudRepository：继承Repository，实现了一组CRUD相关的方法
PagingAndSortingRepository：继承CrudRepository，实现了一组分页排序相关的方法
JpaRepository：继承PagingAndSortingRepository，实现一组JPA规范相关的方法
JpaSpecificationExecutor：比较特殊，不属于Repository体系，实现一组JPA Criteria查询相关的方法

JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

Hibernate3.2+、TopLink 10.1.3以及OpenJPA都提供了JPA的实现。

利用JPA创建MySQL数据库

pom.xml加入JPA和MySQL的依赖

<!--JPA-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

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

配置`JPA`和数据库

application.yml

spring:
  profiles:
    active: a
  datasource:
          driver-class-name: com.mysql.jdbc.Driver
          url: jdbc:mysql://localhost:3306/db_person
          username: root
          password: root

  jpa:
        hibernate:
          ddl-auto: update
          show-sql: true

格式很重要格式很重要格式很重要重要事情说三遍
需要自己手动去创建 db_person 数据库

以下就是我格式不对造成的问题截图：

如果项目没有数据源不想去读数据源配置而报的错，可以：

1.在启动类的@EnableAutoConfiguration或@SpringBootApplication中添加exclude= {DataSourceAutoConfiguration.class}，

排除此类的autoconfig。启动以后就可以正常运行。这是因为添加了数据库组件，所以autoconfig会去读取数据源配置，

而我新建的项目还没有配置数据源，所以会导致异常出现。

2：不用改动添加语句，注意项目文件结构的正确性，确保配置正确也ok

Person.java

package com.xf.curdhibernate.pojo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue
    private  Integer id;
    private String name;
    private Integer age;

    //必须要有构造函数
    public Person() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    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;
    }
}

运行项目后，查看数据库，会自动创建表 person 接下来就可以进行person表的增删改查了

首先创建一个接口PersonRepository，位于dao包下,PersonController调用该接口继承自CrudRepository的方法，来实现和数据库交互

这个PersonRepository接口的功能，与SSM框架中 dao 层接口功能有异曲同工之妙；在SSM框架中，Service层通过该接口，间接执行Mybatis数据库映射文件(.xml)里的相应sql语句，执行数据库增删改查的操作。(Mapper自动实现DAO接口)

`Spring Boot JPA-Hibernate`

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


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


有这么几点需要强调下：
1. Repository是一个空接口，即是一个标记接口；
2. 若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。
3. 实际上也可以通过@RepositoryDefinition,注解来替代继承Repository接口。
4. 查询方法以find | read | get开头；
5. 涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写。
6.使用@Query注解可以自定义JPQL语句实现更灵活的查询。PersonRepository.java

                                                CrudRepository接口
CrudRepository 接口提供了最基本的对实体类的添删改查操作
  --T save(T entity);//保存单个实体   
  --Iterable<T> save(Iterable<? extends T> entities);//保存集合         
  --T findOne(ID id);//根据id查找实体          
  --boolean exists(ID id);//根据id判断实体是否存在          
  --Iterable<T> findAll();//查询所有实体,不用或慎用!          
  --long count();//查询实体数量          
  --void delete(ID id);//根据Id删除实体          
  --void delete(T entity);//删除一个实体   
  --void delete(Iterable<? extends T> entities);//删除一个实体的集合          
  --void deleteAll();//删除所有实体,不用或慎用!

                                 PagingAndSortingRepository接口
该接口提供了分页与排序功能   
 --Iterable<T> findAll(Sort sort); //排序    
--Page<T> findAll(Pageable pageable); //分页查询（含排序功能）

其他接口

JpaRepository：查找所有实体，排序、查找所有实体，执行缓存与数据库同步

JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法，封装  JPA Criteria 查询条件。
通常使用匿名内部类的方式来创建该接口的对象。

自定义 Repository：可以自己定义一个MyRepository接口。

`PersonRepository`

package com.xf.curdhibernate.dao;

import com.xf.curdhibernate.pojo.Person;
import org.springframework.data.repository.CrudRepository;

public interface PersonRepository extends CrudRepository<Person,Integer> {



}

`PersonService`

package com.xf.curdhibernate.service;

import com.xf.curdhibernate.dao.PersonRepository;
import com.xf.curdhibernate.pojo.Person;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.transaction.Transactional;

@Service
public class PersonService {

    @Resource
    private PersonRepository repository;

    /**
     * save,update ,delete 方法需要绑定事务.
     *
     * 使用@Transactional进行事务的绑定.
     *
     * @param person
     */

    //保存数据.
    @Transactional
    public void save(Person person){
        repository.save(person);
    }

    //删除数据
    @Transactional
    public void delete(int id){
        repository.delete(id);
    }

    //查询数据.
    public Iterable<Person> getAll(){
        return repository.findAll();
    }
}

`PersonController`

package com.xf.curdhibernate.Controller;

import com.xf.curdhibernate.pojo.Person;
import com.xf.curdhibernate.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping(value = "/person")
public class PersonController {

    @Autowired
    private PersonService personService;

    @RequestMapping(value ="/add")
    public String save() {
        Person person = new Person();
        person.setName("测试");
        person.setAge(22);
        personService.save(person);
        return "save  ok!";
    }

    @RequestMapping(value = "/delete")
    public String delete() {
        personService.delete(3);
        return "delete ok!";
    }


    @RequestMapping(value = "/getAll")
    public Iterable<Person> getAll(){
        return personService.getAll();
    }


}

Spring Boot JdbcTemplate

在pom.xml加入jdbcTemplate的依赖
<dependency>
		    <groupId>org.springframework.boot</groupId>
		    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

如果在JPA已经加入的话，则可以不用引入以上的配置。
<dependency>
		    <groupId>org.springframework.boot</groupId>
		    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

personDao

package com.xf.curdhibernate.dao;

import com.xf.curdhibernate.pojo.Person;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository  //使用@Repository注解，标注这是一个持久化操作对象.
public class PersonDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    public Person selectByPersonName(String personName){

        /**
         * 1、定义一个Sql语句；
         * 2、定义一个RowMapper.
         * 3、执行查询方法.
         */
        String sql = "select *from person where name=?";
        RowMapper<Person> rowMapper = new BeanPropertyRowMapper<>(Person.class);
        Person person = jdbcTemplate.queryForObject(sql, new Object[]{personName}, rowMapper);

        return person;
    }
}

personService

package com.xf.curdhibernate.service;

import com.xf.curdhibernate.dao.PersonDao;
import com.xf.curdhibernate.pojo.Person;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;


@Service
public class PersonService {

    @Resource
    private PersonDao personDao;


    public Person selectByPersonName(String personName){
        return personDao.selectByPersonName(personName);
    }
}

personController

package com.xf.curdhibernate.Controller;

import com.xf.curdhibernate.pojo.Person;
import com.xf.curdhibernate.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping(value = "/person")
public class PersonController {

    @Autowired
    private PersonService personService;


    @RequestMapping(value = "/selectByPersonName")
    public Person selectByPersonName(String personName){
        return personService.selectByPersonName(personName);
    }


}

测试：

springboot之hello word

SpringBoot

微服务

第一个SpringBoot程序

maven配置的中央仓库阿里云镜像

使用`IDEA`创建SpringBoot项目

自定义属性配置

获取配置文件中的属性值

配置文件中值配置方式的多样化

关于配置文件`application.yml`的多套配置

SpringBoot增删改查实例

Controller的使用

spring-data-jpa

利用JPA创建MySQL数据库

配置`JPA`和数据库

`Spring Boot JPA-Hibernate`

`PersonRepository`

`PersonService`

`PersonController`

猜你喜欢

springboot之hello word

SpringBoot

微服务

第一个SpringBoot程序

maven配置的中央仓库阿里云镜像

使用IDEA创建SpringBoot项目

自定义属性配置

获取配置文件中的属性值

配置文件中值配置方式的多样化

关于配置文件application.yml的多套配置

SpringBoot增删改查实例

Controller的使用

spring-data-jpa

利用JPA创建MySQL数据库

配置JPA和数据库

Spring Boot JPA-Hibernate

PersonRepository

PersonService

PersonController

猜你喜欢

使用`IDEA`创建SpringBoot项目

关于配置文件`application.yml`的多套配置

配置`JPA`和数据库

`Spring Boot JPA-Hibernate`

`PersonRepository`

`PersonService`

`PersonController`