微框架spring boot-阿里云开发者社区

什么是spring boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

为什么要使用spring boot

Spring IO大量的XML配置以及复杂的依赖管理一直是其饱受非议的一点。而Boot的实现不仅仅实现了免XML配置的开发体验，而且在一些场景中甚至不需要编写繁琐的import语句。Spring Boot的目标不在于为已解决的问题域提供新的解决方案，而是为平台带来另一种开发体验，从而简化对这些已有技术的使用。对于已经熟悉Spring生态系统的开发人员来说，Boot是一个很理想的选择，不过对于采用Spring技术的新人来说，Boot提供一种更简洁的方式来使用这些技术。

使用Spring Boot

要进行打包和分发的工程会依赖于像 Maven或 Gradle这样的构建系统。为了简化依赖图，Boot的功能是模块化的，通过导入Boot所谓的“starter”模块，可以将许多的依赖添加到工程之中。官方网站给我们提供了集成相关服务的项目例子，我们直接下载 https://start.spring.io/。

为了更容易地管理依赖版本和使用默认配置，框架提供了一个parent POM，工程可以继承它。Spring Boot工程的样例POM文件定义如下所示：

[html]view plain copy
<?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.example</groupId>  
    <artifactId>demo</artifactId>  
    <version>0.0.2-SNAPSHOT</version>  
    <!-- Boot默认打包为jar -->  
    <packaging>war</packaging>  
  
    <name>demo</name>  
    <description>Demo project for Spring Boot</description>  
  
    <parent>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-parent</artifactId>  
        <version>1.5.4.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>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-web-services</artifactId>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-web</artifactId>  
        </dependency>  
        <!-- 这里指定打包的时候不再需要tomcat相关的包 -->  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-tomcat</artifactId>  
            <!-- 打包时需要添加以下依赖 -->  
            <!--<scope>provided</scope>-->  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-test</artifactId>  
            <scope>test</scope>  
        </dependency>  
        <!-- Spring Boot JDBC -->  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-jdbc</artifactId>  
        </dependency>  
        <!-- 热部署 -->  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-devtools</artifactId>  
            <!-- optional=true,依赖不会传递，该项目依赖devtools；之后依赖myboot项目的项目如果想要使用devtools，需要重新引入 -->  
            <optional>true</optional>  
        </dependency>  
        <!--整合cxf-->  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-frontend-jaxws</artifactId>  
            <version>3.1.6</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.cxf</groupId>  
            <artifactId>cxf-rt-transports-http</artifactId>  
            <version>3.1.6</version>  
        </dependency>  
        <!-- HikariCP依赖 -->  
        <dependency>  
            <groupId>com.zaxxer</groupId>  
            <artifactId>HikariCP</artifactId>  
            <!-- 版本号可以不用指定，Spring Boot会选用合适的版本 -->  
        </dependency>  
        <!-- mybatis-->  
        <dependency>  
            <groupId>org.mybatis.spring.boot</groupId>  
            <artifactId>mybatis-spring-boot-starter</artifactId>  
            <version>1.1.1</version>  
        </dependency>  
        <!-- 分页插件 -->  
        <dependency>  
            <groupId>com.github.pagehelper</groupId>  
            <artifactId>pagehelper</artifactId>  
            <version>4.1.0</version>  
        </dependency>  
        <!-- httpclient -->  
        <dependency>  
            <groupId>org.apache.httpcomponents</groupId>  
            <artifactId>httpclient</artifactId>  
            <version>4.1.2</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.httpcomponents</groupId>  
            <artifactId>httpclient-cache</artifactId>  
            <version>4.1.2</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.httpcomponents</groupId>  
            <artifactId>httpmime</artifactId>  
            <version>4.1.2</version>  
        </dependency>  
        <!-- json-lib-->  
        <dependency>  
            <groupId>net.sf.json-lib</groupId>  
            <artifactId>json-lib</artifactId>  
            <version>2.4</version>  
            <classifier>jdk15</classifier>  
        </dependency>  
        <!-- 加入静态文件和jsp -->  
        <!--对jsp的支持-->  
        <dependency>  
            <groupId>org.apache.tomcat.embed</groupId>  
            <artifactId>tomcat-embed-jasper</artifactId>  
            <!-- 打包时需要添加以下依赖 -->  
            <!--<scope>provided</scope>-->  
        </dependency>  
        <!--配置servlet-->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>  
        </dependency>  
        <!-- MYSQL -->  
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.7</version>  
            <scope>system</scope>  
            <systemPath>${basedir}/src/lib/mysql-connector-java-5.1.7-bin.jar</systemPath>  
        </dependency>  
        <!--添加外部依赖-->  
        <dependency>  
            <groupId>Ice</groupId>  
            <artifactId>Ice</artifactId>  
            <version>1.0</version>  
            <scope>system</scope>  
            <systemPath>${basedir}/src/lib/jsonrpc4j-0.27.jar</systemPath>  
        </dependency>  
        <!--<!– https://mvnrepository.com/artifact/javax.xml.bind/jaxb-api –>-->  
        <!--<dependency>-->  
        <!--<groupId>javax.xml.bind</groupId>-->  
        <!--<artifactId>jaxb-api</artifactId>-->  
        <!--<version>2.2.11</version>-->  
        <!--</dependency>-->  
    </dependencies>  
    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.springframework.boot</groupId>  
                <artifactId>spring-boot-maven-plugin</artifactId>  
            </plugin>  
            <!-- 打包跳过测试 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-surefire-plugin</artifactId>  
                <configuration>  
                    <skip>true</skip>  
                </configuration>  
            </plugin>  
            <!-- maven打包的时候告诉maven不需要web.xml,否刚会报找不到web.xml错误 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-war-plugin</artifactId>  
                <version>2.4</version>  
                <configuration>  
                    <failOnMissingWebXml>false</failOnMissingWebXml>  
                    <!-- 将外部依赖打入war包的lib目录下 -->  
                    <webResources>  
                        <resource>  
                            <directory>src/lib</directory>  
                            <targetPath>WEB-INF/lib/</targetPath>  
                            <includes>  
                                <include>**/*.jar</include>  
                            </includes>  
                        </resource>  
                    </webResources>  
                </configuration>  
            </plugin>  
        </plugins>  
        <!-- 手工设置resource -->  
        <resources>  
            <resource>  
                <directory>src/main/java</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
            <resource>  
                <directory>src/main/resources</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
            <resource>  
                <directory>src/main/webapp</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
        </resources>  
    </build>  
</project>  

构建Boot web应用

1.在配置文件中引入Spring Boot的web依赖：

[html]view plain copy
<dependency>  
           <groupId>org.springframework.boot</groupId>  
           <artifactId>spring-boot-starter-web</artifactId>  
       </dependency>  

spring-boot-starter-web 包含了很多内容，spring-webmvc、spring-web、jackson、validation、tomcat、starter。

2.开始编写代码，由于Maven默认编译路径为 src/main/java 下面的源码，所以，默认设置下，需要创建一些文件夹。

编写文件src\main\java\com\example\hello\HelloController.java:

[html]view plain copy
package com.example.hello;  
  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
  
import java.util.Map;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
  
/**  
 * Created by wuhaochao on 2017/7/12.  
 */  
@RestController  
@RequestMapping("/hello")  
public class HelloController {  
    @RequestMapping("/index")  
    public String index(@RequestParam String name) {  
//        return "hello word" + name;  
        return "index";  
    }  
  
    @RequestMapping("/info")  
    public Map<String, String> getInfo(@RequestParam String name) {  
        Map<String, String> map = new HashMap<>();  
        map.put("name", name);  
        return map;  
    }  
  
    @RequestMapping("/list")  
    public List<Map<String, String>> getList() {  
        List<Map<String, String>> list = new ArrayList<>();  
        Map<String, String> map = null;  
        for (int i = 1; i <= 5; i++) {  
            map = new HashMap<>();  
            map.put("name", "Shanhy-" + i);  
            list.add(map);  
        }  
        return list;  
    }  
}  

@RestController因为我们例子是写一个web应用，因此写的这个注解，这个注解相当于同时添加@Controller和@ResponseBody注解。

创建一个Application类:

[html]view plain copy
package com.example;  
  
import org.apache.cxf.transport.servlet.CXFServlet;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.boot.builder.SpringApplicationBuilder;  
import org.springframework.boot.web.servlet.ServletComponentScan;  
import org.springframework.boot.web.servlet.ServletRegistrationBean;  
import org.springframework.boot.web.support.SpringBootServletInitializer;  
import org.springframework.context.annotation.Bean;  
import org.springframework.scheduling.annotation.EnableAsync;  
import org.springframework.scheduling.annotation.EnableScheduling;  
import org.springframework.transaction.PlatformTransactionManager;  
import org.springframework.transaction.annotation.EnableTransactionManagement;  
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;  
import org.springframework.web.servlet.DispatcherServlet;  
  
//@EnableScheduling//启动定时探测  
@EnableAsync//启动自定义线程池  
@EnableTransactionManagement//启动事物管理  
@SpringBootApplication  
public class DemoApplication extends SpringBootServletInitializer {  
    @Override  
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {  
        return application.sources(DemoApplication.class);  
    }  
  
    @Bean  
    public ServletRegistrationBean restServlet() {  
        //注解扫描上下文  
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();  
        // base package 这里指定到controller不指定*,因为配置有定时任务，容易造成bean冲突，导致定时任务执行2次  
        applicationContext.scan("com.example.controller");  
        // /通过构造函数指定dispatcherServlet的上下文  
        DispatcherServlet rest_dispatcherServlet = new DispatcherServlet(applicationContext);  
        // 用ServletRegistrationBean包装servlet  
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(rest_dispatcherServlet);  
        registrationBean.setLoadOnStartup(1);  
        //指定urlmapping  
        registrationBean.addUrlMappings("/webapp/*");  
        // 指定name，如果不指定默认为dispatcherServlet  
        registrationBean.setName("webapp");  
        return registrationBean;  
    }  
  
    @Bean  
    public Object testBean(PlatformTransactionManager platformTransactionManager) {  
        System.out.println(">>>>>>>>>>>>>>>>>" + platformTransactionManager.getClass().getName() + "<<<<<<<<<<<<<<<<<<<<<");  
        return new Object();  
    }  
  
    public static void main(String[] args) {  
        SpringApplication.run(DemoApplication.class, args);  
    }  
  
}<strong>  
</strong>  

注意Spring Boot建议将我们`main`方法所在的这个主要的配置类配置在根包src名下。

继承SpringBootServletIntializer和方法configure是后期为实现跳转前端页面的配置。

启动项目就可以在浏览器访问了。

数据访问

在配置文件application.properties中配置数据源：

[html]view plain copy
#数据源设置  
spring.datasource.url=jdbc:mysql://localhost:3306/stu_info  
spring.datasource.username=root  
spring.datasource.password=111111  
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.secondary.max-active=50  
spring.datasource.initial-size=5  
spring.datasource.validation-query=SELECT 1  
spring.datasource.test-on-borrow=false  
spring.datasource.test-while-idle=true  
spring.datasource.time-between-eviction-runs-millis=18800  
spring.datasource.jdbc-interceptors=ConnectionState;SlowQueryReport(threshold=0)  
  
#mybatis数据文件路径  
mybatis.mapper-locations=com/example/mapper/sql/*Mapper.xml  
mybatis.type-aliases-package=com.example.entity  

添加mybatis相关依赖：

[html]view plain copy
<!-- mybatis-->  
        <dependency>  
            <groupId>org.mybatis.spring.boot</groupId>  
            <artifactId>mybatis-spring-boot-starter</artifactId>  
            <version>1.1.1</version>  
        </dependency>  
        <!-- 分页插件 -->  
        <dependency>  
            <groupId>com.github.pagehelper</groupId>  
            <artifactId>pagehelper</artifactId>  
            <version>4.1.0</version>  
        </dependency>  

编写mybatis：

[html]view plain copy
package com.example.mapper;  
  
import com.example.entity.TranscationBean;  
import org.apache.ibatis.annotations.Mapper;  
import org.apache.ibatis.annotations.Param;  
  
import java.util.List;  
  
/**  
 * Created by wuhaochao on 2017/7/24.  
 */  
@Mapper  
public interface TranscationMapper {  
    //    获取交易信息  
    List<TranscationBean> getTranscation();  
  
    //    插入交易信息  
    int insertTranscationBean(@Param("transcationBean") TranscationBean transcationBean);  
  
    //    批量插入交易信息  
    int insertTranscationList(@Param("transcationList") List<TranscationBean> transcationList);  
}  

对于的xml文件：

[html]view plain copy
<?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="com.example.mapper.TranscationMapper">  
  
    <!-- type为实体类TranscationBean，包名已经配置，可以直接写类名 -->  
    <resultMap id="transcationMap" type="TranscationBean">  
        <id property="hash" column="transactionHash"/>  
        <result property="transactionIndex" column="transactionIndex"/>  
        <result property="blockHash" column="blockHash"/>  
        <result property="blockNumber" column="blockNumber"/>  
        <result property="from" column="from"/>  
        <result property="to" column="to"/>  
        <result property="nonce" column="nonce"/>  
        <result property="gasPrice" column="gasPrice"/>  
        <result property="gas" column="gas"/>  
        <result property="input" column="input"/>  
        <result property="value" column="value"/>  
        <result property="timestamp" column="timestamp"/>  
    </resultMap>  
    <!-- 查询最新交易信息 -->  
    <select id="getTranscation" resultMap="transcationMap" resultType="TranscationBean">  
        select * from transaction_info t order by t.TIMESTAMP desc  
    </select>  
    <!-- 批量插入交易信息 -->  
    <insert id="insertTranscationList" parameterType="java.util.List">  
        insert into transaction_info VALUES  
        <foreach collection="transcationList" item="trsList" index="index" open="(" close=")" separator=",">  
            #{trsList.hash},#{trsList.transactionIndex},#{trsList.blockHash},  
            #{trsList.blockNumber},#{trsList.from},#{trsList.to},  
            #{trsList.nonce},#{trsList.gasPrice},#{trsList.gas},  
            #{trsList.input},#{trsList.value},#{trsList.timestamp}  
        </foreach>  
    </insert>  
    <!-- 插入交易信息 -->  
    <insert id="insertTranscation" parameterType="TranscationBean">  
        insert into transaction_info VALUES(  
            #{hash},#{transactionIndex},#{blockHash},  
            #{blockNumber},#{from},#{to},  
            #{nonce},#{gasPrice},#{gas},  
            #{input},#{value},#{timestamp}  
            )  
    </insert>  
</mapper>  

配置mybatis分页插件：

[html]view plain copy
package com.example.mapper;  
  
import com.github.pagehelper.PageHelper;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
import java.util.Properties;  
  
/**  
 * Created by wuhaochao on 2017/7/21.  
 */  
@Configuration  
public class MyBatisConfiguration {  
    private static final Logger logger = LoggerFactory.getLogger(MyBatisConfiguration.class);  
  
    @Bean  
    public PageHelper geHelper() {  
        logger.info("注册mybatis分页插件");  
        PageHelper pageHelper = new PageHelper();  
        Properties properties = new Properties();  
        properties.setProperty("offsetAsPageNum", "true");  
        properties.setProperty("rowBoundsWithCount", "true");  
        properties.setProperty("reasonable", "true");  
        pageHelper.setProperties(properties);  
        return pageHelper;  
    }  
}  

控制层调用：

[html]view plain copy
package com.example.controller;  
  
import com.example.entity.TranscationBean;  
import com.example.mapper.TranscationMapper;  
import com.example.unitl.Until;  
import com.fasterxml.jackson.databind.ObjectMapper;  
import com.github.pagehelper.PageHelper;  
import com.github.pagehelper.PageInfo;  
import net.sf.json.JSONArray;  
import net.sf.json.JSONObject;  
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.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
  
/**  
 * Created by wuhaochao on 2017/7/21.  
 */  
  
/**  
 * 交易  
 */  
@RequestMapping("/transcation")  
@RestController  
public class TranscationController {  
    @Autowired  
    private TranscationMapper transcationMapper;  
  
    /**  
     * 获取全部交易信息  
     *  
     * @return  
     * @throws Throwable  
     */  
    @RequestMapping("/getTransInfo")  
    public Object getTranscationInfo() throws Throwable {  
        List<TranscationBean> list = transcationMapper.getTranscation();  
        return list;  
    }  
  
    /**  
     * 分页获取交易信息  
     *  
     * @param pagesize  
     * @return  
     * @throws Throwable  
     */  
    @RequestMapping("/getTransInfo/{pagesize}")  
    public Object getTranscationInfoByPage(@PathVariable("pagesize") Integer pagesize) throws Throwable {  
        PageHelper.startPage(1, pagesize);  
        List<TranscationBean> list = transcationMapper.getTranscation();  
        return new PageInfo(list);  
    }  
  
}  

定时任务

Spring Boot定时任务相对Spring quartz来说更简单。

定义一个定时任务：

[html]view plain copy
package com.example.Scheduled;  
  
/**  
 * Created by wuhaochao on 2017/7/21.  
 */  
  
import com.example.mapper.BlockMapper;  
import com.example.mapper.TranscationMapper;  
import com.example.theadPoolConfig.AsyncTranscationTask;  
import com.example.unitl.Until;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.scheduling.annotation.Scheduled;  
import org.springframework.stereotype.Component;  
import org.springframework.transaction.annotation.Transactional;  
  
/**  
 * 定时任务,每五秒探测一次区块链中的是否存在最新交易信息  
 */  
@Component  
public class MyScheduled {  
    private static final Logger logger = LoggerFactory.getLogger(MyScheduled.class);  
    @Autowired  
    private AsyncTranscationTask asyncTranscationTask;  
    @Autowired  
    private BlockMapper blockMapper;  
  
    /*每天每5秒执行一次*/  
    @Scheduled(cron = "0/5 * * * * ?")  
    @Transactional  
    public void executeTask2() {  
        //        获取最新区块编号  
        try {  
            int blockNumberNew = Integer.parseInt(  
                    Until.encodeHexTodecimal(Until.JSONRPCClient(new Object[]{},  
                            "eth_blockNumber").toString()));  
//          查询数据库中存储的最新区块数据  
            int blockNumberDataSource = blockMapper.getBlockNum();  
            for (int i = blockNumberDataSource + 1; i <= blockNumberNew; i++) {  
                asyncTranscationTask.insertTransTask(i);  
            }  
        } catch (Throwable throwable) {  
            throwable.printStackTrace();  
        }  
    }  
}  

@Scheduled注解定义了定时任务

启动程序中需要加上@EnableScheduling注解启动定时任务探测。

多线程

Spring Boot有自己默认的线程池，这里我们自定义一个自己的线程池。

配置线程池：

[html]view plain copy
package com.example.theadPoolConfig;  
  
/**  
 * Created by wuhaochao on 2017/7/25.  
 */  
  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.scheduling.annotation.EnableAsync;  
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;  
  
import java.util.concurrent.Executor;  
import java.util.concurrent.ThreadPoolExecutor;  
  
/**  
 * 创建自定义线程池  
 */  
@Configuration  
@EnableAsync  
public class TaskExecutePool {  
    @Bean  
    public Executor myTaskAsyncPool() {  
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(10);  
        executor.setMaxPoolSize(50);  
        executor.setQueueCapacity(1000);  
        executor.setKeepAliveSeconds(300);  
  
        // rejection-policy：当pool已经达到max size的时候，如何处理新任务  
        // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        executor.initialize();  
        return executor;  
  
    }  
}  

@EnableAsync注解并发。

使用自定义线程池：

[html]view plain copy
package com.example.theadPoolConfig;  
  
import com.example.entity.BlockInfoBean;  
import com.example.entity.TranscationBean;  
import com.example.mapper.BlockMapper;  
import com.example.mapper.TranscationMapper;  
import com.example.unitl.Until;  
import net.sf.json.JSONArray;  
import net.sf.json.JSONObject;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.scheduling.annotation.Async;  
import org.springframework.stereotype.Component;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/**  
 * Created by wuhaochao on 2017/7/25.  
 */  
@Component  
public class AsyncTranscationTask {  
    private static final Logger logger = LoggerFactory.getLogger(AsyncTranscationTask.class);  
    @Autowired  
    private TranscationMapper transcationMapper;  
    @Autowired  
    private BlockMapper blockMapper;  
  
    //myTaskAsynPool即配置线程池的方法名，此处如果不写自定义线程池的方法名，会使用默认的线程池  
    @Async("myTaskAsyncPool")  
    public void insertTransTask(int i) throws InterruptedException {  
        logger.info("TranscationTask" + i + " started.");  
        //开始导入交易信息  
        String method_BlockByNumber = "eth_getBlockByNumber";  
        JSONObject objects = null;  
        List<TranscationBean> list = null;  
        JSONObject transtionObject = null;  
        TranscationBean transcation = null;  
        try {  
            objects = JSONObject.fromObject(Until.JSONRPCClient(new Object[]{i, true}, method_BlockByNumber));  
        } catch (Throwable throwable) {  
            throwable.printStackTrace();  
        }  
        //插入区块信息  
        BlockInfoBean blockInfoBean = new BlockInfoBean(objects);  
        blockMapper.insertBlockInfo(blockInfoBean);  
        if (JSONArray  
                .fromObject(objects.get("transactions")).size() > 0) {  
            list = new ArrayList<TranscationBean>();  
            for (java.util.Iterator tor = JSONArray  
                    .fromObject(objects.get("transactions"))  
                    .iterator(); tor.hasNext(); ) {  
                transtionObject = (JSONObject) tor.next();  
                transcation = new TranscationBean(transtionObject);  
                transcation.setTimestamp(Until.formatTimeMillis(objects.get("timestamp").toString()));  
                list.add(transcation);  
            }  
            //批量插入  
            transcationMapper.insertTranscationList(list);  
        }  
    }  
  
}  

启动程序中需要加上@ EnableAsync注解启动自定义线程池。

部署

Spring Boot默认打包为jar，按照官方文档操作即可，这里我们打包为war包，可以与前台静态页面交互的web应用。

POM文配置：

[html]view plain copy
<!-- 加入静态文件和jsp -->  
        <!--对jsp的支持-->  
        <dependency>  
            <groupId>org.apache.tomcat.embed</groupId>  
            <artifactId>tomcat-embed-jasper</artifactId>  
            <!-- 打包时需要添加以下依赖 -->  
            <!--<scope>provided</scope>-->  
        </dependency>  
        <!--配置servlet-->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>  
        </dependency>  

[html]view plain copy
<!-- 这里指定打包的时候不再需要tomcat相关的包 -->  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-tomcat</artifactId>  
            <!-- 打包时需要添加以下依赖 -->  
            <!--<scope>provided</scope>-->  
        </dependency>  

[html]view plain copy
<!-- 手工设置resource -->  
        <resources>  
            <resource>  
                <directory>src/main/java</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
            <resource>  
                <directory>src/main/resources</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
            <resource>  
                <directory>src/main/webapp</directory>  
                <includes>  
                    <include>**/*</include>  
                </includes>  
            </resource>  
        </resources>  

[html]view plain copy
<!-- 打包跳过测试 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-surefire-plugin</artifactId>  
                <configuration>  
                    <skip>true</skip>  
                </configuration>  
            </plugin>  
            <!-- maven打包的时候告诉maven不需要web.xml,否刚会报找不到web.xml错误 -->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-war-plugin</artifactId>  
                <version>2.4</version>  
                <configuration>  
                    <failOnMissingWebXml>false</failOnMissingWebXml>  
                    <!-- 将外部依赖打入war包的lib目录下 -->  
                    <webResources>  
                        <resource>  
                            <directory>src/lib</directory>  
                            <targetPath>WEB-INF/lib/</targetPath>  
                            <includes>  
                                <include>**/*.jar</include>  
                            </includes>  
                        </resource>  
                    </webResources>  
                </configuration>  
            </plugin>  

添加本地jar：

[html]view plain copy
<!--添加外部依赖-->  
        <dependency>  
            <groupId>Ice</groupId>  
            <artifactId>Ice</artifactId>  
            <version>1.0</version>  
            <scope>system</scope>  
            <systemPath>${basedir}/src/lib/jsonrpc4j-0.27.jar</systemPath>  
        </dependency>  

微框架spring boot

什么是spring boot

为什么要使用spring boot

使用Spring Boot

注意Spring Boot建议将我们`main`方法所在的这个主要的配置类配置在根包src名下。

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

微框架spring boot

什么是spring boot

为什么要使用spring boot

使用Spring Boot

注意Spring Boot建议将我们main方法所在的这个主要的配置类配置在根包src名下。

热门文章

最新文章

相关课程

相关电子书

相关实验场景

注意Spring Boot建议将我们`main`方法所在的这个主要的配置类配置在根包src名下。