springboot demo搭建

概要

• springboot简介
• 搭建普通的maven项目（本例已maven为例）
• springboot hello world例子
• 数据库访问
• 过滤器filter
• 监听
• servlet
• 事物处理
• 常用的变量配置
• 按环境发布
• 热部署
• 安全策略

springboot简介

1. Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。
2. springboot的主要目标：

• 为所有Spring开发提供一个基本的，更快，更广泛的入门体验。
• 开箱即用，但随着需求开始偏离默认值，快速启动。
• 提供大型项目(例如嵌入式服务器，安全性，度量，运行状况检查，外部化配置)常见的一系列非功能特性。
• 绝对没有代码生成以及不需要XML配置，完全避免XML配置。
• 为了避免定义更多的注释配置(它将一些现有的 Spring Framework 注释组合成一个简单的单一注释)
• 提供一些默认值，以便在短时间内快速启动新项目。

搭建maven项目

略

springboot hello world例子

添加依赖

springboot搭建web项目非常的简单，只需要加入父依赖和启动包即可，启动包里面包含了基本的依赖关系，依赖如下：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.0.RELEASE</version>
</parent>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>1.4.0.RELEASE</version>
</dependency>

restful接口

@RestController
@EnableAutoConfiguration
public class TestController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @RequestMapping("/hello")
    public String test2() {
        return "hello world";
    }
}

启动入口

@Configuration
@EnableAutoConfiguration
@ComponentScan
@EnableAsync
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

这里要注意下，启动入口是会扫描所有的注解代码，所以这里必须写在包的最外层，不然扫描不到

到这里一个基本的springboot的hello world就已经搭建完成了，启动Application的main方法,输入命令：

mvn spring-boot:run

启动完成后，在浏览器输入 http://localhost:8080/hello 即可访问。

打包

为了方便项目打包发布，我们需要在pom文件里面，添加maven插件，代码如下：

<build>
    <finalName>springboottest</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
        </configuration>
      </plugin>
    </plugins>
</build>

打包：<code>mvn package</code>
运行：<code>java -jar target/XXX.jar</code>

数据库访问

这里用mybatis+mysql为例

在pom文件里面添加相关依赖：

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

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.39</version>
</dependency>

配置JDBC信息：

在resources下创建application.yml(也可以创建application.properties，两种风格不一样)，配置信息：

#数据库
spring:
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.56.2:3306/test_spring_boot
    username: admin
    password: 123456

我在数据库里面建了个user表，所以先建一个DBO对象User，代买如下：

public class User {
    private int id;
    private String name;
    private Date birthday;
    private String address;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

创建一个mapper接口：

@Mapper
public interface UserMaper {
    @Select("select * from user where name = #{name}")
    User select(String name);
}

在TestController中新增restful接口：

@Autowired
UserMapper userMaper;

@RequestMapping("/getUser")
public User getuser(String name){
    return userMaper.select(name);
}

启动完成后，在浏览器输入 http://localhost:8080/getUser?name=xinglele，查看返回结果：

{
  "id": 1,
  "name": "xinglele",
  "birthday": "2017-07-19",
  "address": "dddd"
}

过滤器filter

代买如下：

@WebFilter(filterName="myFilter",urlPatterns="/*")
@Order(2)
public class MyFilter implements Filter {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public void destroy() {
        logger.info("过滤器销毁");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        logger.info("执行过滤操作");
        chain.doFilter(request, response);
    }

    @Override
    public void init(FilterConfig config) throws ServletException {
        logger.info("过滤器初始化");
    }

}

只要在类上面加一个WebFilter的注解即可，其中order表示过略的顺序

监听器

下面已监听容器的启动和销毁作为监听的例子，代码如下：

@WebListener
public class IndexListener implements ServletContextListener {
    private Log log = LogFactory.getLog(IndexListener.class);

    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        log.info("IndexListener contextInitialized");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

只要在类上面加WebListener注解即可，容器启动和销毁时，就会被监听到

servlet

代买如下：

@WebServlet(name = "IndexServlet",urlPatterns = "/hello")
public class IndexServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().print("hello word");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req, resp);
    }
}

只要在类上面加WebServlet注解即可。

无论是filter，servlet，listener，启动的时候都需要在入口时加@ServletComponentScan注解。

springboot还提供了另一种方式
采用自己SpringBoot 配置bean的方式进行配置的，SpringBoot提供了三种BeanFilterRegistrationBean、ServletRegistrationBean、ServletListenerRegistrationBean
分别对应配置原生的Filter、Servlet、Listener,下面提供的三个配置和上面采用的方式能够达到统一的效果，代码如下：

@Bean
public ServletRegistrationBean indexServletRegistration() {
    ServletRegistrationBean registration = new ServletRegistrationBean(new IndexServlet());
    registration.addUrlMappings("/hello");
    return registration;
}

@Bean
public FilterRegistrationBean indexFilterRegistration() {
    FilterRegistrationBean registration = new FilterRegistrationBean(new IndexFilter());
    registration.addUrlPatterns("/");
    return registration;
}
@Bean
public ServletListenerRegistrationBean servletListenerRegistrationBean(){
    ServletListenerRegistrationBean servletListenerRegistrationBean = new ServletListenerRegistrationBean();
    servletListenerRegistrationBean.setListener(new IndexListener());
    return servletListenerRegistrationBean;
}

两种方案在使用上有差别，但是在内部SpringBoot的实现上是无差别的，即使使用的是Servlet3.0注解，也是通过扫描注解
转换成这三种bean的FilterRegistrationBean、ServletRegistrationBean、ServletListenerRegistrationBean

事物

关于事务管理器，不管是JPA还是JDBC等都实现自接口 PlatformTransactionManager 如果你添加的是 spring-boot-starter-jdbc 依赖，框架会默认注入 DataSourceTransactionManager 实例。如果你添加的是 spring-boot-starter-data-jpa 依赖，框架会默认注入 JpaTransactionManager 实例。这些对于使用者都是透明的。
使用起来很简单，只要在启动类上加@EnableTransactionManagement，然后在Service中，被 @Transactional 注解的方法，将支持事务：

@Transactional
@Override
public int update() {
    User user = new User();
    user.setId(1);
    user.setName("111");
    userMaper.update(user);


    int i = 0;
    i = 2/i;
    user.setName("222");
    userMaper.update(user);
    return 0;
}

常用的变量配置

在上个demo里面其实我们已经用到了相关的变量，如JDBC的连接。当然也可以设置server的端口和contentpath，如：

#server settings
server:
  port: 8080
  context-path: /spring-boot

当然还可以和传统的spring一样，注入一些配置常量，代码如下：

@Component
@ConfigurationProperties(prefix = "application")
public class ApplicationProperties {
    private String name;
    private String version;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }
}

也可以直接在属性上直接有annotation表示：

@Value("${application.name}")
String name;

application:
  name: m-test-web
  version: 0.0.1

按环境发布

springboot支持分环境打包，如生产环境，测试环境分开部署。实现起来也很简单。
在classpath下，新增application-dev.yml 和 application-prd.yml，一个是本地环境，一个是生产环境，两个环境的一些配置是不一样的。
如果是idea启动，则只要在application.yml中，加入spring.profiles.active=XX，具体指向哪个环境，那么在应用启动时候，就可以读取不通的配置了。
如果是打完包后，使用java命令启动应用，也很简单，只要在启动的时候指定下环境即可：

java -jar target/XX.jar --spring.profiles.activ=prd

这个应该和maven自带的profile区分环境不一样，maven自带的profile是在打包的时候就已经把变量替换了，而springboot应该是在启动的时候把各参数初始化的，个人理解

热部署

以前热部署是用的破解版的jReble，这个蛮好用的，局部编译修改的代码，不需要重启服务器。
springboot自己也做了个热部署的工具，不过这个和jReble不一样，修改完代码后，服务器还是会重新启动的。具体使用方式也很简单，只要在pom里面加入依赖即可使用：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <version>1.4.0.RELEASE</version>
  <optional>true</optional>
</dependency>

注意：idea必须设置成自动编译。

安全监控

参考下：http://blog.csdn.net/king_is_everyone/article/details/53261354