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(); } }
在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); } }
测试: