一步一步学Spring Boot（一）

最新推荐文章于 2025-02-15 10:17:18 发布
原创 最新推荐文章于 2025-02-15 10:17:18 发布 · 5.2k 阅读 · 59 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #技术 #spring-boo #整合 #详细

本文详细介绍了SpringBoot与多种技术的整合方法，包括数据库连接、MyBatis集成、定时任务、消息队列、Swagger文档生成等。通过示例代码展示了如何快速搭建SpringBoot项目，并深入探讨了各组件的具体配置与应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

开心一笑

老板说：“年轻人，如果你想在这里做事，有一件事情你必须要学会，那就是我们这个公司里要求非常干净，你进来时在鞋垫上擦脚了吗？”
年轻人：“哦，擦了，先生。”
老板：“另外一件事是我们要求员工非常诚实，我们门口没有鞋垫”。

提出问题

Spring Boot如何整合其他技术？？？

视频教程

大家好，我录制的视频已经在优快云学院发布了，有兴趣的同学可以购买观看。相信大家一定会收获到很多知识的。谢谢大家的支持……

视频地址：http://edu.youkuaiyun.com/lecturer/994

解决问题

前言

Spring Boot这个技术现在非常流行，网上也有很多的资料，但是都不是很齐全。所以我花了点时间整理了一下，供大家学习。但是有一点要注意的是，这个资料不是很齐全，以后会进行更新，喜欢大家多多支持和鼓励。以后有时间我会录制成视频，供大家学习。

代码在github上面有，可以去下载：* git@github.com:huangwenyi10/my-work.git*

快速搭建Spring Boot项目

如何快速搭建 Spring Boot 项目，可以参考我之前写的一篇博客。

【1】http://blog.youkuaiyun.com/huangwenyi1010/article/details/55047138

Spring Boot 集成mySQL

用JdbcTemplate

参考文章：http://www.cnblogs.com/liangblog/p/5228548.html

1） 添加依赖

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

2）添加配置文件配置数据库和其他参数

在resource文件夹下添加application.properties配置文件并输入数据库参数，如下：

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=10
spring.datasource.max-wait=10000
spring.datasource.min-idle=5
spring.datasource.initial-size=5

server.port=8011
server.session.timeout=10
server.tomcat.uri-encoding=UTF-8

3）新建测试类连接数据库

package com.example.demo;

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.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void contextLoads() {
        List<Map<String,Object>> result = jdbcTemplate.queryForList("select * from ay_test");
        System.out.println("query result is" + result.size());
        System.out.println("success");
    }

}

Spring Boot集成MyBatis

MyBatis的集成总共有3中方式，这里讲解最简单的一种方式。

第1步：引入mybatis的starter的包。 Spring Boot将封装的一系列支持boot的应用的工程都叫做starter，我们这里引入mybatis对boot的支持的starter。如果是同一个的pom，要注释掉mybatis的依赖，starter会自动引入依赖包。

pom.xml

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>12345

第2步：配置properties。

spring.datasource.driver-class-name=com.mysql.jdbc.Driver //1
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=test
spring.datasource.password=123456
spring.datasource.max-active=10
spring.datasource.max-idle=5
spring.datasource.min-idle=0

mybatis.mapper-locations=classpath:/mybatis/*Mapper.xml //2
mybatis.type-aliases-package=com.hjf.boot.demo.boot_mybatis.domain

第3步：生成接口AppMessageMapper文件

package com.example.mybatis.test;
import org.apache.ibatis.annotations.Mapper;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.stereotype.Repository;
import java.util.List;

@Mapper
public interface AppMessageMapper {

    int deleteByPrimaryKey(String id);

    int insert(AppMessage record);

    int insertSelective(AppMessage record);

    AppMessage selectByPrimaryKey(String id);

    int updateByPrimaryKeySelective(AppMessage record);

    int updateByPrimaryKey(AppMessage record);

    List<AppMessage> selectAll();

    List<AppMessage> getMessById(String id);
}

第四步：生成实体类，服务层，服务层实现层，控制层

package com.example.mybatis.test;

import java.util.Date;
public class AppMessage {

    private String id;

    private String message;

    private Date senddate;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message == null ? null : message.trim();
    }

    public Date getSenddate() {
        return senddate;
    }

    public void setSenddate(Date senddate) {
        this.senddate = senddate;
    }
}
package com.example.mybatis.test;

import java.util.ArrayList;
import java.util.List;

public interface IAppMessageService {

    public List<AppMessage> getMessage();
    public List<AppMessage> getAllMessage();
    public int addMessage(AppMessage appMessage);
    public List<AppMessage> getMessageById(String id);
    public int delMessage(String id);
}
package com.example.mybatis.test;

import java.util.ArrayList;
import java.util.List;
import com.example.mybatis.test.AppMessage;
import com.example.mybatis.test.AppMessageMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Component
public class AppMessageService implements IAppMessageService {

    @Autowired
    private AppMessageMapper appMessageMapper;

    @Override
    public List<AppMessage> getMessage(){
        List<AppMessage> list = new ArrayList<>();
        list.add(appMessageMapper.selectByPrimaryKey("xtt"));
        //list = mapper.selectAll();
        return list;
    }

    @Override
    public List<AppMessage> getAllMessage(){
        List<AppMessage> list = new ArrayList<>();
        list = appMessageMapper.selectAll();
        return list;
    }

    @Override
    public int addMessage(AppMessage appMessage) {
        return appMessageMapper.insert(appMessage);
    }

    @Override
    public List<AppMessage> getMessageById(String id) {
        return appMessageMapper.getMessById(id);
    }

    @Override
    public int delMessage(String id) {
        return appMessageMapper.deleteByPrimaryKey(id);
    }



}
package com.example.mybatis.test;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/appmessage")
public class APPMessageController {


    private AppMessageService appMessageService;

    @RequestMapping("/getThree")
    public List<AppMessage> getThreeForMessage(){
        List<AppMessage> list = appMessageService.getMessage();
        return list;
    }

    @RequestMapping("/getAll")
    public List<AppMessage> getAllMessage(){
        List<AppMessage> list = appMessageService.getAllMessage();
        int num = list.size();
        if(null!=list && num>3){
            for (int i = 0; i < num-3; i++) {
                list.remove(0);
            }
        }
        return list;
    }

    @RequestMapping("/getByID")
    public List<AppMessage> getMessageById(@RequestParam("id") String id){
        List<AppMessage> list = appMessageService.getMessageById(id);
        int num = list.size();
        if(null!=list && num>5){
            for (int i = 0; i < num-5; i++) {
                list.remove(0);
            }
        }
        return list;
    }

    @RequestMapping(value = "/add",method = RequestMethod.POST)
    public int addMessage(@RequestBody AppMessage appMessage){
        return appMessageService.addMessage(appMessage);
    }

    @RequestMapping(value="/delMessageById",method=RequestMethod.POST)
    public int delMessageById(@RequestParam("id") String id){
        return appMessageService.delMessage(id);
    }
}

第五步：创建数据库表（mysql数据库）

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `appuser_message`
-- ----------------------------
DROP TABLE IF EXISTS `appuser_message`;
CREATE TABLE `appuser_message` (
  `id` varchar(32) DEFAULT NULL,
  `message` varchar(500) DEFAULT NULL,
  `senddate` date DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
-- ----------------------------
-- Records of appuser_message
-- ----------------------------
INSERT INTO `appuser_message` VALUES ('1', '1', '2017-07-28');

文件的目录图如下：

QQ截图20170727111913

参考文章*

【1】http://m.blog.youkuaiyun.com/mickjoust/article/details/51646658

Spring Boot标签总结

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

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

说明：
1：用这个注解，就能实现自动扫描包和自动配置默认配置的功能，它包含了@ComponentScan和@EnableAutoConfiguration这两个注解，同时这个类自身也是一个配置类@Configuration，可以直接在这个类里添加@Bean来注入java bean，第一章用的注解组合实现的和这个注解功能是一致的，这也是Spring Boot官方推荐的配置方式。

@configuration

用@Configuration注解该类，等价于XML中配置beans；用@Bean标注方法等价于XML中配置bean。

代码如下：

package SpringStudy;  

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import SpringStudy.Model.Counter;  
import SpringStudy.Model.Piano;  

@Configuration  
public class SpringConfig {  
   @Bean  
   public Piano piano(){  
        return new Piano(); 
    }  

   @Bean(name = "counter")   
   public Counter counter(){  
        return  new Counter(12,"Shake it Off",piano());  
   }  
}
@ImportResource

类级别注解，当我们必须使用一个xml的配置时，使用@ImportResource和@Configuration来标识这个文件资源的类。

编写ConfigClass注入配置文件application-bean.xml;

在com.kfit.config包下编写类ConfigClass，这个确保能被Spring Boot可以扫描到，不然一切都付之东流了，具体代码如下：

com.kfit.config].ConfigClass：

package com.kfit.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
/**
 * classpath路径：locations={"classpath:application-bean1.xml","classpath:application-bean2.xml"}
 * file路径： locations = {"file:d:/test/application-bean1.xml"};
 */
@Configuration
@ImportResource(locations={"classpath:application-bean.xml"})
//@ImportResource(locations={"file:d:/test/application-bean1.xml"})
public class ConfigClass {

}
@RestController
@RequestMapping
@value

通过@value注解来读取application.properties里面的配置

face++ key
face_api_key = R9Z3Vxc7ZcxfewgVrjOyrvu1d-qR  
face_api_secret =D9WUQGCYLvOCIdsbX35uTH****  
@Value("${face_api_key}")  
private String API_KEY;  
@Value("${face_api_secret}")  
private String API_SECRET;

注意使用這個注解的时候 使用@Value的类如果被其他类作为对象引用，必须要使用注入的方式，而不能new。这个很重要，我就是被这个坑了。

Spring Boot 整合Quartz

第一步：添加依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.3</version>
</dependency>

第二步：定义配置文件 quartz.xml，名字自己取就可以了

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.2.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <aop:config proxy-target-class="true"/>
    <context:annotation-config/>
    <!-- 利用import引入定时器的文件 -->
    <import resource="spring-quartz.xml"/>

</beans>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- 使用MethodInvokingJobDetailFactoryBean，任务类可以不实现Job接口，通过targetMethod指定调用方法-->
    <bean id="taskJob" class="com.example.quartz.test.TestTask"/>
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="group" value="job_work"/>
        <property name="name" value="job_work_name"/>
        <!--false表示等上一个任务执行完后再开启新的任务-->
        <property name="concurrent" value="false"/>
        <property name="targetObject">
            <ref bean="taskJob"/>
        </property>
        <property name="targetMethod">
            <value>run</value>
        </property>
    </bean>
    <!--  调度触发器 -->
    <bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="name" value="work_default_name"/>
        <property name="group" value="work_default"/>
        <property name="jobDetail">
            <ref bean="jobDetail" />
        </property>
        <property name="cronExpression">
            <value>0/10 * * * * ?</value>
        </property>
    </bean>
    <!-- 调度工厂 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="myTrigger"/>
            </list>
        </property>
    </bean>
</beans>

第三步：创建定时器需要的类 TestTask

package com.example.quartz.test;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TestTask {

    /** 日志对象 */
    private static final Logger LOG = LoggerFactory.getLogger(TestTask.class);
    public void run() {
        if (LOG.isInfoEnabled()) {
            LOG.info("测试任务线程开始执行");
        }
        System.out.println("quarty run .....");
    }
}

第四步：让spring boot扫描到配置文件

主要是这个注解 @ImportResource(locations={“classpath:spring-mvc.xml”})，这样spring boot就可以扫描到我们的配置文件了

package com.example;

import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootApplication
@ImportResource(locations={"classpath:spring-mvc.xml"})
@EnableScheduling
public class DemoApplication{

   @Autowired
   private JmsTemplate jmsTemplate;

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

多个配置文件的整合

例如，项目中有多个xml配置文件：

  • Spring-Common.xml位于common文件夹下
  • Spring-Connection.xml位于connection文件夹下

  • Spring-ModuleA.xml位于moduleA文件夹下

    你可以在代码中加载以上3个xml配置文件

ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"Spring-Common.xml","Spring-Connection.xml","Spring-ModuleA.xml"});

但是这种方法不易组织并且不好维护，最好的方法是在一个单独的xml的配置文件中组织其他所有的xml配置文件。例如，可以创建一个Spring-All-Module.xml文件，然后将其他的xml配置文件导入到Spring-All-Module.xml中，就像下边这样，

Spring-All-Module.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <import resource="common/Spring-Common.xml"/>
    <import resource="connection/Spring-Connection.xml"/>
    <import resource="moduleA/Spring-ModuleA.xml"/>
</beans>

现在，你可以在代码中加载一个单独的xml配置文件，如下：

ApplicationContext context =    new ClassPathXmlApplicationContext(Spring-All-Module.xml);

Spring Boot整合Redis

第一步：添加依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-redis -->
<!-- 注意包都要拿最新的版本 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

第二步：配置properties

#redis
spring.redis.database=0
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=0
第三步：测试类
package com.example.redis.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author Ay
 * @date   2017/1/24.
 */
@RestController
@EnableAutoConfiguration
public class HelloRedisTestController {

    @Resource
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/redis")
    public String index(){
        // 保存字符串
        stringRedisTemplate.opsForValue().set("aaa", "111");
        String string = stringRedisTemplate.opsForValue().get("aaa");
        System.out.println(string);
        return "Hello Ay...";
    }
}
参考文章

【1】http://blog.youkuaiyun.com/helenyqa/article/details/60575885

Spring Boot 整合 ActiveMQ

安装

【1】

第一步：添加依赖

<!-- ActiveMQ dependency start-->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jms</artifactId>
</dependency>
<dependency>
   <groupId>org.apache.activemq</groupId>
   <artifactId>activemq-client</artifactId>
</dependency>
<!-- ActiveMQ dependency end-->

第二步：定义配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.2.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <aop:config proxy-target-class="true"/>
    <context:annotation-config/>

    <import resource="spring-quartz.xml"/>


    <!-- 配置JMS连接工厂 -->
    <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="failover:(tcp://localhost:61616)" />
    </bean>

    <!-- 定义消息队列（Queue） -->
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <!-- 设置消息队列的名字 -->
        <constructor-arg>
            <value>myQueue</value>
        </constructor-arg>
    </bean>

    <!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="defaultDestination" ref="queueDestination" />
        <property name="receiveTimeout" value="10000" />
    </bean>

    <!--queue消息生产者 -->
    <bean id="producerService" class="com.example.mq.test.ProducerServiceImpl">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
    </bean>

    <!--queue消息消费者 -->
    <bean id="consumerService" class="com.example.mq.test.ConsumerServiceImpl">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
    </bean>

</beans>

第三步：定义消费者和生产者类

生产者类接口ProducerService

package com.example.mq.test;

import org.springframework.stereotype.Component;

import javax.jms.Destination;

public interface ProducerService {

    /**
     * 发消息，向默认的 destination
     * @param msg String 消息内容
     */
    public void sendMessage(String msg);

    /**
     * 发消息，向指定的 destination
     * @param destination 目的地
     * @param msg String 消息内容
     */
    public void sendMessage(Destination destination, String msg);

    /**
     * 发消息，向指定的 destination
     * @param destination 目的地
     * @param msg String 消息内容
     */

    /**
     * 向指定的destination发送消息，消费者接受消息后，把回复的消息写到response队列
     * @param destination 目的地
     * @param msg String 消息内容
     * @param response 回复消息的队列
     */
    public void sendMessage(Destination destination, String msg, Destination response);
}

生产者类实现

package com.example.mq.test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

public class ProducerServiceImpl implements ProducerService{

    @Autowired
    private JmsTemplate jmsTemplate;

    public JmsTemplate getJmsTemplate() {
        return jmsTemplate;
    }

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    /**
     * 向指定队列发送消息
     */
    public void sendMessage(Destination destination, final String msg) {
        System.out.println("向队列" + destination.toString() + "发送了消息------------" + msg);
        jmsTemplate.send(destination, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });
    }

    /**
     * 向默认队列发送消息
     */
    public void sendMessage(final String msg) {
        String destination =  jmsTemplate.getDefaultDestination().toString();
        System.out.println("向队列" +destination+ "发送了消息------------" + msg);
        jmsTemplate.send(new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });

    }

    @Override
    public void sendMessage(Destination destination, String msg, Destination response) {

    }
}

消费者类

package com.example.mq.test;

import javax.jms.Destination;

public interface ConsumerService {

    public void receive(Destination queueDestination);

}

消费者类实现

package com.example.mq.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.TextMessage;

public class ConsumerServiceImpl implements ConsumerService{

    @Autowired
    private JmsTemplate jmsTemplate;

    public JmsTemplate getJmsTemplate() {
        return jmsTemplate;
    }

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    /**
     * 接受消息
     */
    public void receive(Destination destination) {
        TextMessage tm = (TextMessage) jmsTemplate.receive(destination);
        try {
            System.out.println("从队列" + destination.toString() + "收到了消息：\t" + tm.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

上面的消费者也可以用 监听器来实现，在上面的配置文件中，添加如下配置：

<!-- 配置消息队列监听者（Queue），代码下面给出，只有一个onMessage方法 -->
<bean id="queueMessageListener" class="com.example.mq.test.QueueMessageListener" />

<!-- 消息监听容器（Queue），配置连接工厂，监听的队列是queue2，监听器是上面定义的监听器 -->
<bean id="jmsContainer"  class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="destination" ref="queueDestination" />
    <property name="messageListener" ref="queueMessageListener" />
</bean>

创建消费者监听器类：

package com.example.mq.test;

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class QueueMessageListener implements MessageListener {

    //当收到消息时，自动调用该方法。
    public void onMessage(Message message) {
        TextMessage tm = (TextMessage) message;
        try {
            System.out.println("ConsumerMessageListener收到了文本消息：\t" + tm.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

需要把之前的消费者接口和实现类删除掉

第四步：运行测试类

package com.example.demo;

import com.example.mq.test.ConsumerService;
import com.example.mq.test.ProducerService;
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.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import javax.jms.Destination;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

   @Autowired
   private JdbcTemplate jdbcTemplate;

   @Autowired
   private ProducerService producerService;
   @Autowired
   private ConsumerService consumerService;
   @Autowired
   private Destination queueDestination;

   @Test
   public void myMQProductorTest(){
      producerService.sendMessage("hello ay....");
   }

   @Test
   public void myMQComsumerTest(){
      consumerService.receive(queueDestination);
   }

}

Spring Boot定时器使用

第一步：在入口类中加入@EnableScheduling注解：

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class DemoApplication{

   @Autowired
   private JmsTemplate jmsTemplate;

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

第二步：创建定时器类，类中的方法注解了@Scheduled就是一个定时器：

package com.example.quartz.test;

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
@Configurable
@EnableScheduling
public class ScheduledTasks{

    @Scheduled(fixedRate = 1000 * 30)
    public void reportCurrentTime(){
        System.out.println ("Scheduling Tasks Examples: The time is now " + dateFormat ().format (new Date()));
    }

    //每1分钟执行一次
    @Scheduled(cron = "0 */1 *  * * * ")
    public void reportCurrentByCron(){
        System.out.println ("Scheduling Tasks Examples By Cron: The time is now " + dateFormat ().format (new Date ()));
    }

    private SimpleDateFormat dateFormat(){
        return new SimpleDateFormat ("HH:mm:ss");
    }

}

没了，没错，使用spring的定时任务就这么简单，其中有几个比较重要的注解：

@EnableScheduling：标注启动定时任务。

@Scheduled(fixedRate = 1000 * 30) 定义某个定时任务。

第三步：运行项目

参考文档

【1】http://blog.youkuaiyun.com/clementad/article/details/51955705

Spring Boot 整合Swagger

第一步：添加Swagger2依赖

在pom.xml中加入Swagger2的依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.2.2</version>
</dependency>

第二步：创建Swagger2配置

在Application.java同级创建Swagger2的配置类Swagger2。

@Configuration
@EnableSwagger2
public class Swagger2 {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.didispace.web"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot中使用Swagger2构建RESTful APIs")
                .description("更多Spring Boot相关文章请关注：http://blog.didispace.com/")
                .termsOfServiceUrl("http://blog.didispace.com/")
                .contact("程序猿DD")
                .version("1.0")
                .build();
    }

}

如上代码所示，通过@Configuration注解，让Spring来加载该类配置。再通过@EnableSwagger2注解来启用Swagger2。

再通过createRestApi函数创建Docket的Bean之后，apiInfo()用来创建该Api的基本信息（这些基本信息会展现在文档页面中）。select()函数返回一个ApiSelectorBuilder实例用来控制哪些接口暴露给Swagger来展现，本例采用指定扫描的包路径来定义，Swagger会扫描该包下所有Controller定义的API，并产生文档内容（除了被@ApiIgnore指定的请求）。

第三步：测试类

package com.example.demo;

import io.swagger.annotations.ApiOperation;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Ay
 * @date   2017/1/24.
 */
@RestController
@RequestMapping(value="/hello")
@EnableAutoConfiguration
public class AyTestController {

    @RequestMapping("/ay")
    @ApiOperation(value = "ay",httpMethod ="GET", response = String.class,notes = "index")
    public String index(){
        return "Hello Ay...";
    }

    @RequestMapping("/test")
    @ApiOperation(value = "test",httpMethod ="GET", response = String.class,notes = "index")
    public String test(){
        return "Hello Ay...";
    }
}

完成上述代码添加上，启动Spring Boot程序，访问：http://localhost:8080/swagger-ui.html
。就能看到前文所展示的RESTful API的页面。我们可以再点开具体的API请求，以POST类型的/users请求为例，可找到上述代码中我们配置的Notes信息以及参数user的描述信息，如下图所示。

在完成了上述配置后，其实已经可以生产文档内容，但是这样的文档主要针对请求本身，而描述主要来源于函数等命名产生，对用户并不友好，我们通常需要自己增加一些说明来丰富文档内容。如下所示，我们通过@ApiOperation注解来给API增加说明、通过@ApiImplicitParams、@ApiImplicitParam注解来给参数增加说明。

QQ截图20170727135453

Spring Boot实现过滤器filter

第一步：定义MyFilter过滤器

package org.springboot.sample.filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;

/**

- 使用注解标注过滤器
- @WebFilter将一个实现了javax.servlet.Filter接口的类定义为过滤器
- 属性filterName声明过滤器的名称,可选
- 属性urlPatterns指定要过滤 的URL模式,也可使用属性value来声明.(指定要过滤的URL模式是必选属性)
  */
  @WebFilter(filterName="myFilter",urlPatterns="/*")
  public class MyFilter implements Filter {
  @Override
  public void destroy() {
      System.out.println("过滤器销毁");
  }
  @Override
  public void doFilter(ServletRequest request, ServletResponse response,
          FilterChain chain) throws IOException, ServletException {
      System.out.println("执行过滤操作");
      chain.doFilter(request, response);
  }
  @Override
  public void init(FilterConfig config) throws ServletException {
      System.out.println("过滤器初始化");
  }

}

第二步：在入口类添加@ServletComponentScan 注解

package com.example;

import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.context.annotation.ImportResource;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootApplication
@ImportResource(locations={"classpath:spring-mvc.xml"})
@EnableScheduling
//加上这个注解，注意看这里
@ServletComponentScan
public class DemoApplication{

   @Autowired
   private JmsTemplate jmsTemplate;

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


}

第三步：重启项目，随便访问一个路径，既可以被过滤器拦截到。

Spring Boot实现监听器Listener

第一步：定义监听器类

package com.example.listener.test;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

/**
 * 使用@WebListener注解，实现ServletContextListener接口
 * @author   Ay
 */
@WebListener
public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContex初始化");
        System.out.println(sce.getServletContext().getServerInfo());
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContex销毁");
    }

}

第二步：在入口类添加@ServletComponentScan 注解

第三步：重启系统

Spring Boot全局异常处理

全局处理异常的：@ControllerAdvice：包含@Component，可以被扫描到。

统一处理异常。@ExceptionHandler（Exception.class）：用在方法上面表示遇到这个异常就执行以下方法。

package com.example.exception.test;

import org.springframework.beans.TypeMismatchException;
import org.springframework.messaging.handler.annotation.support.MethodArgumentNotValidException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Date;

@ControllerAdvice
//如果返回的为json数据或其它对象，添加该注解
@ResponseBody
public class GlobalDefaultExceptionHandler {

    public static final String DEFAULT_ERROR_VIEW = "error";

    @ExceptionHandler({NullPointerException.class,NumberFormatException.class})
    public ModelAndView formatErrorHandler(HttpServletRequest req, Exception e) throws Exception {
        ModelAndView mav = new ModelAndView();
        mav.addObject("error","参数类型错误");
        mav.addObject("exception", e);
        mav.addObject("url", "");
        mav.addObject("timestamp", new Date());
        mav.setViewName(DEFAULT_ERROR_VIEW);
        return mav;
    }

}

结束语

你的鼓励，我的动力，一分都是爱


读书感悟

来自《楚乔传》

  • 在比你强大的敌人面前，无论有多么害怕恐惧，都不要颤抖，要笑，灿烂地笑。
  • 有一种感情，无论顺境逆境，无论风雨水火，无论刀山火海，都不会被世事磨碎，都不会被时光打磨，它的名字，叫做信任。
  • 永远不要嘲笑一个爱你的男人，如果有一天他不爱你了，他比你爹都成熟。
  • 我这一生可以放弃任何人，唯独阿楚！

经典故事

《昂起头来真美》

——别看它是一条黑母牛，牛奶一样是白的。

珍妮是个总爱低着头的小女孩，她一直觉得自己长得不够漂亮。有一天，她到饰物店去买了只绿色蝴蝶结，店主不断赞美她戴上蝴蝶结挺漂亮，珍妮虽不信，但是挺高兴，不由昂起了头，急于让大家看看，出门与人撞了一下都没在意。珍妮走进教室，迎面碰上了她的老师，“珍妮，你昂起头来真美！”老师爱抚地拍拍她的肩说。

那一天，她得到了许多人的赞美。她想一定是蝴蝶结的功劳，可往镜前一照，头上根本就没有蝴蝶结，一定是出饰物店时与人一碰弄丢了。自信原本就是一种美丽，而很多人却因为太在意外表而失去很多快乐。

温馨提示：

无论是贫穷还是富有，无论是貌若天仙，还是相貌平平，只要你昂起头来，快乐会使你变得可爱——人人都喜欢的那种可爱。

大神文章

无

其他

如果有带给你一丝丝小快乐，就让快乐继续传递下去，欢迎点赞、顶、欢迎留下宝贵的意见、多谢支持！

从零开始学Spring Boot(Spring Boot技术文档)
09-21
从零开始学Spring Boot(Spring Boot技术文档)
Spring Boot入门，一步一步简化，实现Spring Web项目开发
热门推荐
Mistra的博客
08-17 1万+
在此之前写过一篇文章 一步一步搭建入门Spring Web应用，本篇文章就是在此基础上，运用Spring Boot来简化Spring Web开发。本篇文章中有些类可能会联系到前面一篇文章中出现的类。一、 Spring Boot介绍Spring Boot诞生的目的就是用来简化Spring应用开发过程。该框架使用了特定的方式来进行配置，从而使得开发人员不在需要定义一系列样板化的配置文件，而专注于核心业
一步一步学习SpringBoot
qq_42019139的博客
09-17 189
一笔一记，加深记忆 一、项目结构 /src/main/java 目录存放所有java文件(源代码) /src/main/resource 目录存放所有静态文件 包括静态资源文件、配置文件、模板页面文件等 /src/main/resource/static 存放各类静态资源 /src/main/resource/templates 存放模板文件 /src/main/resource/appli...
跟着笨鸟一步一步学习spring开发（1 spring mvc 版hello world）
05-16 1952
主要是翻译了一位韩国哥们儿的博客，再加上一些自己的理解。写一个spring mvc开发的系列，当个自己的学习笔记。 原文链接：http://www.mkyong.com/spring3/spring-3-mvc-hello-world-example/ 开发一个最简单的spring mvc版的hello world应用。 技术准备： 1、Spring 3.0.5.RELEASE 2、JD
超详细，从 0 到 1 搭建 Spring Boot 应用
最新发布
linfan1571519609的博客
02-15 1203
通过本文的介绍，我们从零搭建了一个完整的 Spring Boot 应用，涵盖了环境准备、项目创建、依赖引入、应用配置、业务逻辑实现以及运行测试等各个环节。Spring Boot 以其简洁的配置和强大的功能，大大简化了 Java 开发流程。希望本文能对你学习和使用 Spring Boot 提供帮助，让你在开发道路上更进一步。在实际开发中，还可以根据项目需求进一步扩展和优化应用，例如添加安全认证、日志记录、异常处理等功能，以满足不同场景下的开发需求。
一步一步学Spring Boot
06-09
Spring Boot是现在很热门的一个微服务框架，作为一名Java Web 开发工程师，是必须要掌握它的。本系列课程会一步一步教大家如何使用Spring Boot，以及Spring Boot如何整合其它技术。
Spring Boot 2 一步一步学微服务项目实战
12-14
Spring Boot 2 一步一步学微服务项目实战 出版时间：2018-08-01
读书笔记：《一步一步学Spring Boot微服务项目实战》源码.zip
07-23
读书笔记：《一步一步学Spring Boot微服务项目实战》源码
读书笔记：一步一步学spring boot2微服务项目实战第二版.zip
07-25
读书笔记：一步一步学spring boot2微服务项目实战第二版
spring-boot-demo：Spring Boot的基础教程，由浅入深，一步一步学习Spring Boot，最后学到的不单单是基础！Spring Cloud基础教程请看：https：github.comroncoospring-cloud-demo
01-29
如果没有使用过Spring Boot，也是一个学习的好项目。 龙库充值 项目地址：| 具备话费充值，流量充值，话费卡兑换功能； 可以拓展其他充值兑换业务，某种虚拟币充值； 也适用于支付，鉴权等业务功能的发展。
springboot dubbox 实例 (springbootdubbox-consumer)
01-20
springboot dubbox 实例 http://knight-black-bob.iteye.com/blog/2354087
springboot——第一步（简单搭建）
niketwo的专栏
10-17 418
springboot优劣本帖就不说明了，仅作为简单创建之用。 按照习惯，依然使用maven创建项目（基础环境及maven如果还未搭建，可百度一下）。 一、新建maven项目 依次点击：File->new->other，然后输入maven,最终选择Manve Project，然后next; 默认选择Use default；继续Next。 选择 maven-archtyp...
一步一步学习：1、Spring-boot初步认识
程序猿-大城哥
06-28 368
一、初步认识Spring-boot以前在使用spring框架的时候，各种配置文件，繁琐复杂、配置项太多，Spring Boot让我们的Spring应用变的更轻量化。比如：你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。Spring Boot的主要优点： 为所有Spring开发者更快的入门 开箱即用
初学Spring必须弄懂的几个知识点
IT之常青藤
07-27 6680
一. spring的关键在于它的AOP和IOC，所以首先要弄懂AOP和IOC的原理，深入理解了这两方面才算是入门了。 1.IoC(Inversion of control): 控制反转  （将以前我们在代码中new的工作交给了spring容器） 概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系  核心：bean工厂；在Spring中，bean工厂创建的
快速学习 Spring Boot 技术栈
程序视界
11-04 1956
这是“纯洁的微笑”新上线的 GitChat 达人课，16 篇文章讲解 Spring Boot 技术栈，学完可以使用 Spring Boot 上手开发。 作者简介 纯洁的微笑，曾经先后在互联网金融、第三方支付公司担任高级 Java 工程师、架构师、技术经理、技术负责人等职务。在互联网金融工作期间，从零参与公司技术平台建设，组织平台进行过四次大架构升级。目前在一家第三方支付
通过3天小小的学习springboot，我掌握到了什么（上）
qq_36597450的博客
07-06 2163
听说多写博客的人工资不会太低使用idea创建springboot太**快了，省去了很多xml的配置，我都有时间多逛逛贴吧和帖子了。        1.创建springboot项目只需打勾勾就行了，把web打钩把使用的模板打钩相应的jar包就能导入，当然这是基于maven，不过对于小白找jar包这种事情省了一大半时间，配置完了就可以跑了，这就是以前累死累活配的springxml项目。。。。     ...
第1章 第一个Spring Boot项目
IT技术分享
09-22 2597
11
spring boot(一):详细入门篇
ApassionBoy
09-27 628
关于springboot这里就不多说了，现在大部分企业都是用的它，想必听过了，这里是我自学时的笔记，来做一下分享 这里说一下使用springboot的优势： 敏捷开发、开箱即用，提供各种默认配置来简化项目配置 tomcat内嵌式容器简化Web项目 使用了maven的依赖管理，减少了冗余代码生成和XML配置的要求 今天这里主要目标就是完成Spring Boot基础项目的构建，实现一个简单的HT...
一步一步学Spring Boot（三）
IT技术分享
09-13 927
课程名称《一步一步学Spring Boot（三）》学习地址优快云学习地址： http://edu.youkuaiyun.com/lecturer/99451CTO学习地址：http://edu.51cto.com/lecturer/5592452.html课程介绍Spring Boot是现在很热门的一个微服务框架，作为一名Java Web 开发工程师，是必须要掌握它的。本系列课程会一步一步教大家如何使用Spr
intellij spring initializr 怎么一步一步建造spring boot?
01-30
为了创建一个新的Spring Boot项目，可以利用IntelliJ IDEA中的Spring Initializr功能来简化这一过程[^4]。 ### 使用IntelliJ IDEA和Spring Initializr创建Spring Boot项目的指南 #### 打开IntelliJ并启动新项目 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@阿_毅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值