一、Spring Boot

Spring是JavaEE轻量级代替品。无需开发重量级的(EJB),Spring为企业级Java开发提供了一种相对简单的方法,通过依赖注入和面向切面编程,用简单的POJO对象实现了EJB的功能。虽然Spring 的组件代码是轻量级的,但它的配置却是重量级的。

SpringBoot 简化了基于Spring的应用开发,只需要 "run" 就能创建一个独立的、生产级别的Spring应用。SpringBoot为Spring平台及第三方库提供开箱即用的设置(提供默认设置)。多数SpringBoot应用只需要很少的Spring配置。使用java –jar 启动它,或者采用传统的war部署方式。

SpringBoot主要目标

为所有 Spring 的开发提供一个从根本上更快的入门体验

开箱即用,但通过自己设置参数,即可快速摆脱这种方式。

提供了一些大型项目中常见的非功能性特性,如内嵌服务器、安全、指标,健康检测、外部化配置等

绝对没有代码生成,也无需 XML 配置。

2. Spring Boot 入门
2.1. 环境准备
数据库:MySQL

IDE:Eclipse Mars2

Spring-Boot:1.4.4

Maven: 3.3.3 (官方声明1.4.4版本需要Maven 3.2+)

本地仓库:需要使用资料中的仓库

2.2. 起步依赖
2.2.1. 创建一个Maven工程

2.2.2. 添加依赖
在pom.xml中添加依赖,效果如下

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.4.4.RELEASE</version>

</parent>

<groupId>cn.itcast.springboot</groupId>

<artifactId>itcast-springboot</artifactId>

<version>0.0.1-SNAPSHOT</version>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

我们会惊奇地发现,我们的工程自动添加了好多好多jar 包,而这些jar 包正式我们做开发时需要导入的jar 包。

因为这些jar 包被我们刚才加入的spring-boot-starter-web 所引用了,所以添加spring-boot-starter-web后会自动把依赖传递过来。

2.3. 变更JDK版本
我们发现默认情况下工程的JDK版本是1.6,但是通常使用的是1.7的版本

修改JDK为1.7,需要在pom.xml中添加以下配置:

<properties>

<java.version>1.7</java.version>

</properties>

使用Maven更新工程后,就发现版本已经变成1.8了

注意:

虽然JDK1.6或者1.7都可以使用Spring-Boot,但Spring-Boot官方建议使用JDK1.8。要使用JDK1.8,首先必须要配置JDK1.8后,才可以使用上述方法设置。

2.4. 引导类
需要创建一个引导类:

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class Demo {

public static void main(String[] args) {

SpringApplication.run(Demo.class, args);

}

}

这里多了一个@SpringBootApplication注解

@Configuration: 用于定义一个配置类

@EnableAutoConfiguration :Spring Boot 会自动根据你jar 包的依赖来自动配置

项目。

@ComponentScan: 告诉Spring 哪个packages 的用注解标识的类会被spring

自动扫描并且装入bean 容器。

Banner

直接启动,控制台出现以下标识。

.   ____          _            __ _ _

/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \

( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \

\\/  ___)| |_)| | | | | || (_| |  ) ) ) )

'  |____| .__|_| |_|_| |_\__, | / / / /

=========|_|==============|___/=/_/_/_/

:: Spring Boot ::        (v1.4.4.RELEASE)

这个标识是Spring启动标识,如果不想要,可以设置取消

import org.springframework.boot.Banner.Mode;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class Application {

public static void main(String[] args) {

// SpringApplication.run(Application.class, args);

SpringApplication application = new SpringApplication(Application.class);

application.setBannerMode(Mode.OFF);

application.run(args);

}

}

参考附录二的banner设置,可以通过修改配置文件制定自己的标识。

2.5. 入门程序
需求:使用Spring MVC实现Hello World输出

2.5.1. 原来的实现
我们现在开始使用spring MVC 框架,实现json 数据的输出。如果按照我们原来的做法,需要在web.xml 中添加一个DispatcherServlet 的配置,还需要添加一个spring的配置文件,配置文件如下配置

spring加入配置

<!-- controller注解扫描 -->

<context:component-scan base-package="cn.itcast.springboot.controller" />

<!-- 注解驱动 -->

<mvc:annotation-driven />

web.xml加入配置

<!-- 配置前端控制器 -->

<servlet>

<servlet-name> itcast-springboot</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring/*.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name> itcast-springboot</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

还要编写Controller。。。

2.5.2. Spring-Boot的实现
我们不需要配置文件,直接编写Controller类即可

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

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

@RestController

public class HelloWorldController {

@RequestMapping("info")

public String info() {

return "Hello world!";

}

}

@RestController注解:其实就是@Controller和@ResponseBody注解加在一起

启动方式一:启动之前编写的引导类即可

启动方式二:使用Maven命令spring-boot:run执行即可

选择 Maven Build

在浏览器地址栏输入http://localhost:8080/info 即可看到运行结果

2.6. 热部署
我们在开发中反复修改类、页面等资源,每次修改后都是需要重新启动才生效,这样每次启动都很麻烦,浪费了大量的时间。

能不能在我修改代码后不重启就能生效呢?可以,由于Spring Boot应用只是普通的Java应用,所以JVM热交换(hot-swapping)也能开箱即用。不过JVM热交换能替换的字节码有限制,想要更彻底的解决方案可以使用Spring Loaded项目或JRebel。 spring-boot-devtools 模块也支持应用快速重启(restart)。

我们只需要在pom.xml加入如下配置即可

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

</dependency>

3. SpringBoot整合
3.1. 整合Spring Data JPA
3.1.1. 需求
使用Spring Boot + Spring MVC + Spring Data JPA + EasyUI 框架组合实现部门列表查询,效果如下:

3.1.2. 环境准备
3.1.2.1. 导入数据库表
在MySQL数据库执行以下语句

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (

`id` bigint(20) NOT NULL AUTO_INCREMENT,

`user_name` varchar(100) DEFAULT NULL COMMENT '用户名',

`password` varchar(100) DEFAULT NULL COMMENT '密码',

`name` varchar(100) DEFAULT NULL COMMENT '姓名',

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

INSERT INTO `user` VALUES ('1', 'zhangsan', '123456', '张三');

INSERT INTO `user` VALUES ('2', 'lisi', '123456', '李四');

INSERT INTO `user` VALUES ('3', 'wangwu', '123456', '王五');

INSERT INTO `user` VALUES ('4', 'zhangwei', '123456', '张伟');

INSERT INTO `user` VALUES ('5', 'lina', '123456', '李娜');

INSERT INTO `user` VALUES ('6', 'lilei', '123456', '李磊');

3.1.2.2. 创建Maven工程
itcast-info(打jar包),在pom.xml中进行如下配置

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.4.4.RELEASE</version>

</parent>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<version>1.4.4.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<version>1.4.4.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

<version>1.4.4.RELEASE</version>

</dependency>

<dependency>

<groupId>mysql</groupId>

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

<version>5.1.6</version>

</dependency>

</dependencies>

3.1.2.3. 加入Spring-Boot配置文件
在src/main/resources 下添加application.properties 配置文件,内容如下:

#DB Configuration:

spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao

spring.datasource.username=root

spring.datasource.password=root

#JPA Configuration:

spring.jpa.database=MySQL

spring.jpa.show-sql=true

spring.jpa.generate-ddl=true

spring.jpa.hibernate.ddl-auto=update

spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy

此文件用于覆盖Spring Boot的默认配置,完整的配置信息参考“附录2”

3.1.3. 后端实现
3.1.3.1. 创建实体类
import javax.persistence.Entity;

import javax.persistence.Id;

@Entity

public class User {

@Id

private Long id;

private String userName;

private String password;

private String name;

//添加 get 和set 方法

}

3.1.3.2. 创建DAO接口
import org.springframework.data.jpa.repository.JpaRepository;

import cn.itcast.info.pojo.User;

public interface UserDao extends JpaRepository<User, Long> {

}

3.1.3.3. 创建业务逻辑接口
import java.util.List;

import cn.itcast.info.pojo.User;

public interface UserService {

List<User> findAll();

}

3.1.3.4. 创建业务逻辑实现类
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import cn.itcast.info.dao.UserDao;

import cn.itcast.info.pojo.User;

import cn.itcast.info.service.UserService;

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserDao userDao;

@Override

public List<User> findAll() {

List<User> list = this.userDao.findAll();

return list;

}

}

3.1.3.5. 创建Controller
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

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

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

import cn.itcast.info.pojo.User;

import cn.itcast.info.service.UserService;

@RestController

@RequestMapping("user")

public class UserControlelr {

@Autowired

private UserService userService;

@RequestMapping("list")

public List<User> queryUserAll() {

List<User> list = this.userService.findAll();

return list;

}

}

3.1.3.6. 创建引导类
import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

运行引导类Application,打开浏览器输入http://127.0.0.1:8080/user/list

3.1.4. 前端实现
把资料中的static文件夹,拷贝到src/main/resources路径下

浏览器地址栏输入:http://127.0.0.1:8080/user.html,效果如下

运行引导类Application

3.2. 整合MyBatis
3.2.1. 简单整合
3.2.1.1. 加入依赖
在pom.xml中加入以下依赖

<!-- SpringBoot的Mybatis启动器 -->

<dependency>

<groupId>org.mybatis.spring.boot</groupId>

<artifactId>mybatis-spring-boot-starter</artifactId>

<version>1.1.1</version>

</dependency>

3.2.1.2. 编写Mapper
和之前的方式一样,只是多了两个注解

@Mapper:声明Mapper接口

@Select:声明这个接口所需要使用的sql,当然,有查询的注解,肯定就有增删改的注解。

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select;

import cn.itcast.info.pojo.User;

@Mapper

public interface UserMapper {

@Select("select * from user where name like '%${value}%'")

public List<User> queryUserByName(String name);

}

3.2.1.3. 编写Service和Controller
添加Service调用Mapper

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserDao userDao;

@Autowired

private UserMapper userMapper;

@Override

public List<User> findAll() {

List<User> list = this.userDao.findAll();

return list;

}

@Override

public List<User> queryUserByName(String name) {

List<User> list = this.userMapper.queryUserByName(name);

return list;

}

}

修改Controller

@RestController

@RequestMapping("user")

public class UserControlelr {

@Autowired

private UserService userService;

@RequestMapping("list")

public List<User> queryUserAll() {

List<User> list = this.userService.findAll();

return list;

}

@RequestMapping("list/{name}")

public List<User> queryUserAll(@PathVariable String name) {

List<User> list = this.userService.queryUserByName(name);

return list;

}

}

3.2.1.4. 测试
浏览器地址栏输入:http://127.0.0.1:8080/user/list/张

显示效果:

3.2.2. 整合通用Mapper和分页助手
以上所有的配置都是使用的默认配置,我们只需要专注java代码的开发即可,不需要加入配置文件了。

但并不是所有得场景都是简单的业务,有时候业务复杂,需要我们加入自定义的配置文件;有时候需要载入例如分页助手这样的插件,辅助开发,所以我们也需要了解如何加载这些配置。

3.2.2.1. 加入依赖
我们需要加入通用Mapper和分页插件,所以需要在pom.xml加入以下依赖

<!-- 通用Mapper -->

<dependency>

<groupId>com.github.abel533</groupId>

<artifactId>mapper</artifactId>

<version>2.3.4</version>

</dependency>

<!-- 分页助手 -->

<dependency>

<groupId>com.github.pagehelper</groupId>

<artifactId>pagehelper</artifactId>

<version>3.7.5</version>

</dependency>

<dependency>

<groupId>com.github.jsqlparser</groupId>

<artifactId>jsqlparser</artifactId>

<version>0.9.1</version>

</dependency>

3.2.2.2. 修改配置文件
在application.properties添加配置

#spring集成Mybatis环境

#pojo别名扫描包

mybatis.type-aliases-package=cn.itcast.info.pojo

#加载Mybatis核心配置文件

mybatis.mapper-locations=classpath:mapper/*Mapper.xml

mybatis.config-location=classpath:mybatis/SqlMapConfig.xml

#配置连接池,还需要在pom.xml中加入该连接池的依赖

#spring.datasource.type=com.jolbox.bonecp.BoneCPDataSource

在src\main\resources\mapper路径下加入UserMapper.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="cn.itcast.info.dao.UserMapper">

<select id="queryAll" resultType="user">

select * from user

</select>

</mapper>

在src\main\resources\mybatis加入SqlMapConfig.xml配置文件,用以加载通用Mapper和分页助手

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

<!-- 分页助手 -->

<plugins>

<plugin interceptor="com.github.pagehelper.PageHelper">

<property name="dialect" value="mysql" />

<!-- 该参数默认为false -->

<!-- 设置为true时,使用RowBounds分页会进行count查询 -->

<property name="rowBoundsWithCount" value="true" />

</plugin>

<!-- 通用Mapper -->

<plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">

<!--主键自增回写方法,默认值MYSQL,详细说明请看文档 -->

<property name="IDENTITY" value="MYSQL" />

<!--通用Mapper接口,多个通用接口用逗号隔开 -->

<property name="mappers" value="com.github.abel533.mapper.Mapper" />

</plugin>

</plugins>

</configuration>

3.2.2.3. 编写Mapper
import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select;

import cn.itcast.info.pojo.User;

//extends com.github.abel533.mapper.Mapper<User>:需要继承通用Mapper

@Mapper

public interface UserMapper extends com.github.abel533.mapper.Mapper<User> {

@Select("select * from user where name like '%${value}%'")

public List<User> queryUserByName(String name);

// 使用UserMapper.xml配置文件

public List<User> queryAll();

}

3.2.2.4. 编写Service和Controller
Service编写

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.github.pagehelper.PageHelper;

import cn.itcast.info.dao.UserDao;

import cn.itcast.info.dao.UserMapper;

import cn.itcast.info.pojo.User;

import cn.itcast.info.service.UserService;

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserDao userDao;

@Autowired

private UserMapper userMapper;

@Override

public List<User> findAll() {

List<User> list = this.userDao.findAll();

return list;

}

@Override

public List<User> queryUserByName(String name) {

List<User> list = this.userMapper.queryUserByName(name);

return list;

}

// 调用使用UserMapper.xml的Mapper

@Override

public List<User> queryAll() {

List<User> list = this.userMapper.queryAll();

return list;

}

// 使用通用Mapper和分页助手

@Override

public List<User> queryUserByPage(Integer page, Integer rows) {

// 设置分页

PageHelper.startPage(page, rows);

// 使用通用Mapper的方法进行查询所有数据

List<User> list = this.userMapper.select(null);

return list;

}

}

Controller编写

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.PathVariable;

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

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

import cn.itcast.info.pojo.User;

import cn.itcast.info.service.UserService;

@RestController

@RequestMapping("user")

public class UserControlelr {

@Autowired

private UserService userService;

@RequestMapping("list")

public List<User> queryUserAll() {

List<User> list = this.userService.findAll();

return list;

}

@RequestMapping("list/{name}")

public List<User> queryUserAll(@PathVariable String name) {

List<User> list = this.userService.queryUserByName(name);

return list;

}

@RequestMapping("list/query")

public List<User> queryUserAll2() {

List<User> list = this.userService.queryAll();

return list;

}

@RequestMapping("list/{page}/{rows}")

public List<User> queryUserAll(@PathVariable Integer page, @PathVariable Integer rows) {

List<User> list = this.userService.queryUserByPage(page, rows);

return list;

}

}

3.2.2.5. 测试
测试使用UserMapper.xml

浏览器地址栏输入:http://127.0.0.1:8080/user/list/query

测试使用通用Mapper和分页助手

浏览器地址栏输入:http://127.0.0.1:8080/user/list/2/2

3.3. 整合Redis
3.3.1. 注解方式实现添加缓存
需求:基于上例代码,将列表数据缓存到Redis

3.3.1.1. 加入依赖
在pom.xml加入依赖

<!-- 配置使用redis启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-redis</artifactId>

</dependency>

3.3.1.2. 修改引导类
修改开启缓存,添加注解@EnableCaching

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication

@EnableCaching

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

3.3.1.3. 设置实现序列化接口
需要修改实体,让实体实现序列化接口

@Entity

public class User implements Serializable {

@Id

private Long id;

private String userName;

private String password;

private String name;

。。。。。。

}

3.3.1.4. 实现添加/删除缓存
修改UserServiceImpl,添加@Cacheable注解实现缓存添加

@Override

@Cacheable(value = "userCache", key = "'user.findAll'")

public List<User> findAll() {

System.out.println("从Mysql中查询");

List<User> list = this.userDao.findAll();

return list;

}

@Override

@CacheEvict(value = "userCache", key = "'user.findAll'")

public List<User> queryUserByName(String name) {

System.out.println("缓存清理了!");

List<User> list = this.userMapper.queryUserByName(name);

return list;

}

这样设置完成后,执行findAll()方法就会使用缓存,如果缓存没有就添加缓存,而queryUserByName(String name)方法则是删除缓存

@Cacheable:添加/使用缓存

@CacheEvict:删除缓存

参数value是缓存的名字,在执行的时候,会找叫这个名字的缓存使用/删除

参数key默认情况下是空串””,是Spring的一种表达式语言SpEL,我们这里可以随意指定,但是需要注意一定要加单引号

3.3.2. redis的深入使用
3.3.2.1. 直接操作redis
redis除了作为缓存使用,还有很多其他的作用,例如利用redis的单线程获取唯一数,例如使用redis为单点登录系统存储用户登录信息等,我们就需要直接操作redis。

官网提供了三种接口RedisConnectionFactory, StringRedisTemplate 和 RedisTemplate,我们可以直接注入或者自己实现其他的实现类,来直接操作redis。我们这里使用RedisTemplate来操作Redis。

如下所示,我们只需要直接注入RedisTemplate即可使用以下方法操作redis的五种不同的数据类型

测试:

@Autowired

private RedisTemplate<String, String> redisTemplate;

@Override

@CacheEvict(value = "userCache", key = "'user.findAll'")

public List<User> queryUserByName(String name) {

// 保存数据

this.redisTemplate.boundValueOps("redis").set("Hello redis !");

// 设置有效时间为100秒

this.redisTemplate.boundValueOps("redis").expire(100l, TimeUnit.SECONDS);

// 给value每次执行加一操作

this.redisTemplate.boundValueOps("count").increment(1l);

System.out.println("缓存清理了!");

List<User> list = this.userMapper.queryUserByName(name);

return list;

}

3.3.2.2. 设置redis连接属性
redis单机版

redis启动器默认情况下会找本地的redis服务,端口号默认是6379如果需要访问其他服务器的redis,则需要在application.properties中进行如下配置:

#Redis

spring.redis.host=192.168.37.161

spring.redis.port=6379

这表示会去找ip为192.168.37.161和端口为6379的服务

redis集群版

#Redis

#spring.redis.host=192.168.37.161

#spring.redis.port=6379

#Redis Cluster

spring.redis.cluster.nodes=192.168.37.161:7001,192.168.37.161:7002,192.168.37.161:7003,192.168.37.161:7004,192.168.37.161:7005,192.168.37.161:7006

切换到集群版只需要做以上配置,配置集群版节点信息,注释掉单机版信息

3.4. 整合ActiveMQ
3.4.1. 加入依赖
在pom.xml中加入以下配置

<!-- 配置ActiveMQ启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-activemq</artifactId>

</dependency>

3.4.2. 创建队列
在引导类中添加以下方法,设置队列

@SpringBootApplication

@EnableCaching

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

@Bean

public Queue queue() {

return new ActiveMQQueue("itcast.queue");

}

}

3.4.3. 发送消息
编写Controller,发送消息

import javax.jms.Destination;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.web.bind.annotation.PathVariable;

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

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

@RestController

@RequestMapping("queue")

public class QueueController {

//注入发送消息的对象

@Autowired

private JmsTemplate jmsTemplate;

//注入消息队列

@Autowired

private Destination destination;

//编写发送消息的方法

@RequestMapping("send/{message}")

public String send(@PathVariable String message) {

this.jmsTemplate.convertAndSend(destination, message);

return "消息发送成功!消息内容:" + message;

}

}

3.4.4. 接收消息
编写bean,加入@Component注解让spring管理这个bean,作为接收消息的消费者

import org.springframework.jms.annotation.JmsListener;

import org.springframework.stereotype.Component;

@Component

public class Consumer {

// 接受消息方法

@JmsListener(destination = "itcast.queue")

public void readMessage(String text) {

System.out.println("接受到的消息是:" + text);

}

}

测试:

启动服务后,在浏览器执行http://127.0.0.1:8080/queue/send/发消息了11

即可看到消息发送成功

同时可以在控制台看到打印信息

我们没有安装ActiveMQ,为什么可以使用?因为Spring Boot 内置了ActiveMQ 的服务,所以我们不用单独启动也可以实现消息的发送和接收。

3.4.5. 使用外部服务
首先确认有一台外部ActiveMQ服务可以使用

在application.properties中加入以下配置

#ActiveMQ

spring.activemq.broker-url=tcp://192.168.37.161:61616

这样就加入了ActiveMQ服务的地址

3.5. 整合junit
3.5.1. 加入依赖
在pom.xml中加入测试依赖

<!-- 配置测试启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

<scope>test</scope>

</dependency>

3.5.2. 编写测试类
import javax.jms.Destination;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.jms.core.JmsTemplate;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.info.Application;

@RunWith(SpringJUnit4ClassRunner.class)

@SpringBootTest(classes = Application.class)

public class MessageTest {

@Autowired

private Destination destination;

@Autowired

private JmsTemplate jmsTemplate;

@Test

public void test() {

System.out.println("我发消息了!");

this.jmsTemplate.convertAndSend(destination, "Hello ActiveMQ!");

}

}

SpringRunner 与SpringJUnit4ClassRunner 是继承关系,但是没有不同的地方,只是看起来子类SpringRunner要短一些而已。

@SpringBootTest 注解的class 属性要指定引导类的class

3.6. 整合dubbox
3.6.1. 环境准备
3.6.1.1. dubbox
dubbo是一个分布式的服务架构,可直接用于生产环境作为SOA服务框架。官网首页:http://dubbo.io/

淘宝将这个项目开源出来以后,得到了不少同行的支持,包括:

当当网的扩展版本dubbox :https://github.com/dangdangdotcom/dubbox

京东的扩展版本jd-hydra: http://www.oschina.NET/p/jd-hydra

不过,略有遗憾的是, dubbo由于某些原因导致dubbo团队已经解散,已经很牛没有更新了,反到是当当网的扩展版本仍在持续发展。因为dubbox支持更新的spring版本,所以我们使用dubbox。

Dubbox在maven中央仓库并没有对应的依赖,所以我们需要自己动手将其发布到我们的本地仓库来使用。

使用git从码云上把dubbox的代码clone下来,

地址:https://git.oschina.net/wuyu15255872976/dubbox.git

执行Maven命令把工程安装到本地仓库

命令:clean install -Dmaven.test.skip

课程资料提供的仓库已经安装好了,可以直接使用

3.6.1.2. spring-boot-starter-dubbo
我们以前在使用dubbo的时候都是用的xml配置。而在整合Spring Boot的时候可以使用@ImportResource注解来引入的dubbo的xml配置。

但是Spring Boot本身并不推荐xml配置。怎么解决这个矛盾,我们可以自己准备一个Spring Boot Starter dubbo的项目来引导Spring Boot对Dubbo的自动化配置。已经有人开发好了这个自动化配置项目,我们直接使用就行了

使用git从码云上把spring-boot-starter-dubbo的代码clone下来,

地址:https://git.oschina.net/wuyu15255872976/spring-boot-starter-dubbo.git

执行Maven命令把工程安装到本地仓库

命令:clean install -Dmaven.test.skip

为了统一管理,把pom.xml修改为如下:

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

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.4.4.RELEASE</version>

</parent>

<artifactId>spring-boot-starter-dubbo</artifactId>

<version>1.4.4.RELEASE</version>

<name>Spring Boot Dubbo Rpc</name>

<description>Spring Boot Dubbo Rpc</description>

<url>http://projects.spring.io/spring-boot/</url>

<organization>

<name>Pivotal Software, Inc.</name>

<url>http://www.spring.io</url>

</organization>

<properties>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<java.version>1.7</java.version>

</properties>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-actuator</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-configuration-processor</artifactId>

</dependency>

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>dubbo</artifactId>

<version>2.8.5-SNAPSHOT</version>

<exclusions>

<exclusion>

<artifactId>spring</artifactId>

<groupId>org.springframework</groupId>

</exclusion>

</exclusions>

</dependency>

<!-- zookeeper 客户端 -->

<dependency>

<groupId>com.github.sgroschupf</groupId>

<artifactId>zkclient</artifactId>

<version>0.1</version>

</dependency>

</dependencies>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-dependencies</artifactId>

<version>1.4.4.RELEASE</version>

<type>pom</type>

<scope>import</scope>

</dependency>

</dependencies>

</dependencyManagement>

<build>

<plugins>

<plugin>

<artifactId>maven-source-plugin</artifactId>

<configuration>

<attach>true</attach>

</configuration>

<executions>

<execution>

<phase>compile</phase>

<goals>

<goal>jar</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

</project>

课程资料提供的仓库已经安装好了,可以直接使用

3.6.1.3. zookeeper注册中心
我们使用zookeeper作为dubbo的注册中心。

这里使用的zookeeper注册中心地址是:192.168.37.161:2181

修改hosts,配置注册中心的域名是zookeeper.taotao.com

3.6.2. 搭建项目
taotao-parent作为所有工程的父工程

taotao- interface作为提供pojo和抽取服务接口的

taotao-provider作为服务提供者

taotao-consumer作为服务消费者

3.6.2.1. 搭建taotao-parent
创建taotao-parent,并打pom包,这里配置公共使用的依赖。

修改pom.xml为如下

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

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.4.4.RELEASE</version>

</parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

<packaging>pom</packaging>

<properties>

<!-- 配置java版本 -->

<java.version>1.7</java.version>

</properties>

<dependencies>

<!-- 配置测试启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

<scope>test</scope>

</dependency>

<!-- 配置web启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<optional>true</optional>

</dependency>

<!-- 配置dubbo启动器 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-dubbo</artifactId>

<version>1.4.4.RELEASE</version>

<optional>true</optional>

</dependency>

</dependencies>

</project>

3.6.2.2. 搭建taotao-interface
创建taotao-interface,并打jar包。

修改pom.xml为如下,几乎不用配置

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

<parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

</parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-interface</artifactId>

<version>0.0.1-SNAPSHOT</version>

</project>

3.6.2.3. 搭建taotao-provider
创建taotao-provider,并打jar包。

修改pom.xml为如下

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

<parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

</parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-provider</artifactId>

<version>0.0.1-SNAPSHOT</version>

<dependencies>

<!-- 加入taotao-interface依赖 -->

<dependency>

<groupId>com.taotao</groupId>

<artifactId>taotao-interface</artifactId>

<version>0.0.1-SNAPSHOT</version>

</dependency>

<!-- 配置MyBatis启动器 -->

<dependency>

<groupId>org.mybatis.spring.boot</groupId>

<artifactId>mybatis-spring-boot-starter</artifactId>

<version>1.1.1</version>

</dependency>

<!-- MySQL连接驱动 -->

<dependency>

<groupId>mysql</groupId>

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

</dependency>

</dependencies>

</project>

3.6.2.4. 搭建taotao-consumer
创建taotao-consumer,并打jar包。

修改pom.xml为如下

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

<parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-parent</artifactId>

<version>0.0.1-SNAPSHOT</version>

</parent>

<groupId>com.taotao</groupId>

<artifactId>taotao-consumer</artifactId>

<version>0.0.1-SNAPSHOT</version>

<dependencies>

<!-- 加入taotao-interface依赖 -->

<dependency>

<groupId>com.taotao</groupId>

<artifactId>taotao-interface</artifactId>

<version>0.0.1-SNAPSHOT</version>

</dependency>

</dependencies>

</project>

3.7. 实现功能
3.7.1. 实现taotao-interface
编写pojo

import java.io.Serializable;

public class User implements Serializable {

private Long id;

private String userName;

private String password;

private String name;

get/set方法

}

编写Service接口

import com.taotao.common.pojo.User;

public interface UserService {

public User queryUserById(Long id);

}

3.7.2. 实现taotao-provider
编写UserMapper

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select;

import com.taotao.common.pojo.User;

@Mapper

public interface UserMapper {

@Select("select * from user where id=#{id}")

public User queryUserById(Long id);

}

编写UserServiceImpl实现类

import org.springframework.beans.factory.annotation.Autowired;

import com.alibaba.dubbo.config.annotation.Service;

import com.taotao.common.consumer.UserService;

import com.taotao.common.pojo.User;

import com.taotao.mapper.UserMapper;

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserMapper userMapper;

@Override

public User queryUserById(Long id) {

User user = this.userMapper.queryUserById(id);

return user;

}

}

编写引导类

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;

@SpringBootApplication

@EnableDubboAutoConfiguration

public class ProviderApplication {

public static void main(String[] args) {

SpringApplication.run(ProviderApplication.class, args);

}

}

在src/main/resources加入配置文件application.properties

#DB Configuration:

spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao

spring.datasource.username=root

spring.datasource.password=root

#配置服务器访问端口号

server.port=8081

#配置dubbo信息

#配置服务名称

spring.dubbo.application.name=taotao-provider

#注册中心类型

spring.dubbo.registry.protocol=zookeeper

#注册中心连接方式

spring.dubbo.registry.address=manager.taotao.com:2181

#配置服务调用所使用的协议

spring.dubbo.protocol.name=dubbo

#配置服务端口号

spring.dubbo.protocol.port=20880

#配置服务访问地址

spring.dubbo.protocol.host=localhost

#配置dubbo扫描

spring.dubbo.scan=com.taotao.provider

3.7.3. 实现taotao-consumer
编写Controller

import org.springframework.web.bind.annotation.PathVariable;

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

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

import com.alibaba.dubbo.config.annotation.Reference;

import com.taotao.common.consumer.UserService;

import com.taotao.common.pojo.User;

@RestController

@RequestMapping("user")

public class UserController {

@Reference

private UserService userService;

@RequestMapping("{id}")

public User queryUserById(@PathVariable Long id) {

User user = this.userService.queryUserById(id);

return user;

}

}

编写引导类

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;

@SpringBootApplication

@EnableDubboAutoConfiguration

public class ConsumerApplication {

public static void main(String[] args) {

SpringApplication.run(ConsumerApplication.class, args);

}

}

在src/main/resources加入配置文件application.properties

#配置服务器访问端口号

server.port=8080

#配置dubbo信息

#配置服务名称

spring.dubbo.application.name=taotao-consumer

#注册中心类型

spring.dubbo.registry.protocol=zookeeper

#注册中心连接方式

spring.dubbo.registry.address=manager.taotao.com:2181

#配置服务调用所使用的协议

spring.dubbo.protocol.name=dubbo

#配置服务端口号

spring.dubbo.protocol.port=20880

#配置服务访问地址

spring.dubbo.protocol.host=localhost

#配置dubbo扫描

spring.dubbo.scan=com.taotao.consumer

4. Spring Boot深入学习
4.1. 读取配置文件
4.1.1. .读取核心配置文件
在工程的src/main/resources 下修改核心配置文件

application.properties, 添加内容如下

name=传智播客

url=http://www.itcast.cn

在Controller中添加:

@Resource

private Environment env;

@RequestMapping("list")

public List<User> queryUserAll() {

System.out.println(env.getProperty("name"));

System.out.println(env.getProperty("url"));

List<User> list = this.userService.findAll();

return list;

}

就可以直接把配置文件信息打印出来。

注意包名是:org.springframework.core.env.Environment

4.1.2. 读取自定义文件
在工程的src/main/resources 下构建自定义配置文件mail.properties, 内容如下

mail.host=smtp.sina.com

mail.port=25

mail.username=itcast

mail.password=heima

编写JavaBean

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

import org.springframework.context.annotation.Configuration;

@Configuration

@ConfigurationProperties(locations = "classpath:mail.properties", prefix = "mail")

public class MailProperties {

private String host;

private Integer port;

private String username;

private String password;

set/get

}

改造Controller

@Autowired

private MailProperties mailProperties;

@RequestMapping("/mailInfo")

public String mailInfo() {

return mailProperties.getHost() + "<br>" + mailProperties.getPort() + "<br>" + mailProperties.getUsername()

+ "<br>" + mailProperties.getPassword();

}

打印效果

4.2. 打jar包
在工程的pom.xml中添加以下依赖

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

我们目前的工程采用的是jar 的打包方式,所以我们在执行package 命令后,

会产生一个jar 包。

我们进入到这个目录用压缩软件打开此jar 包,其中我们发现了一个叫lib 的文件夹,打开lib 文件夹发现此文件夹下全是工程依赖的jar包,甚至还有tomcat。这种包含有jar 包的jar包,我们称之为fatJAR( 胖jar 包)

由于fatJAR 本身就包括tomcat , 我们就不需要另外部署了,直接在命令行就可以把我们的应用启动起来,在命令行,进入到jar 包所在的目录,我们可以通过以下java –jar命令来执行此jar 包。

在控制台会出现启动信息,在浏览器访问程序

4.3. 打war包
spring-boot 默认提供内嵌的tomcat,所以打包直接生成jar 包,用java

-jar 命令就可以启动。但是,有时候我们更希望一个tomcat 来管理多个项目,

这种情况下就需要项目是war 格式的包而不是jar 格式的包。

我们按照以下步骤完成对工程的改造

(1)修改pom.xml

将打包方式修改为war

<packaging>war</packaging>

添加依赖

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-tomcat</artifactId>

<scope>provided</scope>

</dependency>

spring-boot-starter-tomcat 是原来被传递过来的依赖,默认会打到包里,所

以我们再次引入此依赖,并指定依赖范围为provided,这样tomcat 相关的jar

就不会打包到war 里了.

(2)添加ServletInitializer

import org.springframework.boot.builder.SpringApplicationBuilder;

import

org.springframework.boot.context.web.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {

@Override

protected SpringApplicationBuilder configure(SpringApplicationBuilder

application) {

return application.sources(Application.class);

}

}

由于我们采用web3.0 规范,是没有web.xml 的,而此类的作用与web.xml

相同。

(3)运行package 打包命令生成war 包

生成后将war 包放入tomcat,启动tomcat,测试完成的功能是否可以使用。

SpringBoot学习(一)的更多相关文章

  1. springboot 学习资源推荐

    springboot 是什么?对于构建生产就绪的Spring应用程序有一个看法. Spring Boot优先于配置的惯例,旨在让您尽快启动和运行.(这是springboot的官方介绍) 我们为什么要学 ...

  2. Springboot学习记录1--概念介绍以及环境搭建

    摘要:springboot学习记录,环境搭建: 官方文档地址:https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/ht ...

  3. SpringBoot学习笔记

    SpringBoot个人感觉比SpringMVC还要好用的一个框架,很多注解配置可以非常灵活的在代码中运用起来: springBoot学习笔记: .一.aop: 新建一个类HttpAspect,类上添 ...

  4. springboot学习(一)——helloworld

    以下内容,如有问题,烦请指出,谢谢 springboot出来也很久了,以前零散地学习了不少,不过很长时间了都没有在实际中使用过了,忘了不少,因此要最近准备抽时间系统的学习积累下springboot,给 ...

  5. SpringBoot学习(3)-SpringBoot添加支持CORS跨域访问

    SpringBoot学习(3)-SpringBoot添加支持CORS跨域访问 https://blog.csdn.net/yft_android/article/details/80307672

  6. Springboot学习07-数据源Druid

    Springboot学习07-数据源Druid 关键字 Druid 前言 学习笔记 正文 1-Druid是什么 Druid是阿里巴巴开源平台上的一个项目,整个项目由数据库连接池.插件框架和SQL解析器 ...

  7. Springboot学习06-Spring AOP封装接口自定义校验

    Springboot学习06-Spring AOP封装接口自定义校验 关键字 BindingResult.Spring AOP.自定义注解.自定义异常处理.ConstraintValidator 前言 ...

  8. Springboot学习05-自定义错误页面完整分析

    Springboot学习06-自定义错误页面完整分析 前言 接着上一篇博客,继续分析Springboot错误页面问题 正文 1-自定义浏览器错误页面(只要将自己的错误页面放在指定的路径下即可) 1-1 ...

  9. Springboot学习04-默认错误页面加载机制源码分析

    Springboot学习04-默认错误页面加载机制源码分析 前沿 希望通过本文的学习,对错误页面的加载机制有这更神的理解 正文 1-Springboot错误页面展示 2-Springboot默认错误处 ...

  10. Springboot学习笔记(六)-配置化注入

    前言 前面写过一个Springboot学习笔记(一)-线程池的简化及使用,发现有个缺陷,打个比方,我这个线程池写在一个公用服务中,各项参数都定死了,现在有两个服务要调用它,一个服务的线程数通常很多,而 ...

随机推荐

  1. DapperExtensions 使用教程

    最近搭建一个框架,使用dapper来做数据库访问,数据是sql server2012,支持多个数据库.事务.orm.ado.net原生操作方式,非常方便. 使用dapper的原因网上有很多文章说明,这 ...

  2. 3.3.5 高效读取:不变模式下的CopyOnWriteArrayList

    源码分析:读写(get,add) 一:get 方法 private E get(Object[] a, int index) { return (E) a[index];}可以看到读取数据的时候 没有 ...

  3. Fiddldr 教程之:HTTP协议详解(转)

    原文地址:http://www.cnblogs.com/TankXiao/archive/2012/02/13/2342672.html HTTP协议详解 当今web程序的开发技术真是百家争鸣,ASP ...

  4. 编写高质量代码改善C#程序的157个建议——建议81:使用Parallel简化同步状态下Task的使用

    建议81:使用Parallel简化同步状态下Task的使用 在命名空间System.Threading.Tasks中,有一个静态类Parallel简化了在同步状态下的Task的操作.Parallel主 ...

  5. kafka搜索介绍

    kafka详解  https://blog.csdn.net/liubenlong007/article/details/55211196##1  1.2 Kafka诞生 Kafka由 linked- ...

  6. opencv——pcb上寻找mark点(拟合椭圆的方法)

    #include "stdafx.h" // FitCircle.cpp : 定义控制台应用程序的入口 #include "cv.h" #include &qu ...

  7. Reporting Service服务SharePoint集成模式安装配置(8、配置用于SharePoint 2010的Reporting service模式)

    从SQL Server 2012 起, SQL Server Reporting Service可以完全集成进SharePoint的场,直接作为SharePoint 的组件部分来运行,没有独立的Win ...

  8. Android 画指南针

    1.无意看到了一个指南针的UI,在这里简单的模仿了一下.其实就是第画布的一些变化而已. 别人的效果图是: 3.简单说一下思路: 1)首先是画一个黑色圆盘 2) 然后画圆盘上的刻度(就是对Canvas一 ...

  9. Wait--查看等待

    --清除等待统计 --===================================================== --清除等待统计 DBCC SQLPERF (N'sys.dm_os_ ...

  10. Ubuntu 安装 Memcached

    直接使用命令 sudo apt-get install Memcached 进行安装 安装完, 默认只能本地连接,需要修改一下配制文件,打开 /etc/Memcached.conf 文件, 找到一个 ...