微框架spring boot-低调大师

微框架spring boot

2018-04-19 646

什么是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>  

微信关注我们

原文链接：https://yq.aliyun.com/articles/597863

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

SSM框架详细整合教程（Spring+SpringMVC+MyBatis）

动机使用maven已经有一段时间了，但项目是别人搭建好的，因此一直想着自己要学习搭建一下。网上找了些资料后，结合自己实验，花了点时间就搞好，老样子，写在博客上，免得日后忘记。本文链接：http://blog.csdn.net/v123411739/article/details/50742885 博文中的MyEclipse链接：https://pan.baidu.com/s/1pMhiygz 密码：mqmc 博文中的完整项目代码：关注微信公众号发送“SSM”即可获得。注：文末有直接导入项目的方法。 1.安装maven和配置（此步骤并非必须，可以根据情况选择）进入官网下载中心http://maven.apache.org/download.cgi，下载apache-maven-3.5.2-bin.zip，**-src.zip为Maven的源码配置环境变量，打开系统环境变量新建一个M2_HOME将解压后的Maven存放路径放在此，然后在path路径加入%M2_HOME%\bin路径检测是否配置成功，打开命令行输入echo %M2_HOME%查看M2_HOME指向的Maven存放...

2018-04-20

737

.NET 调用c++库注意事项

原文: .NET 调用c++库注意事项很久没有更新了，主要还是因为自己懒吧，希望从今天开始坚持至少一周写一篇文章。调用函数库是正常的，调用完成后，在使用EF进行数据更新时，将发生如下异常信息，而且几乎必现。行库遇到了错误。此错误的地址为0x79e8eda2，在线程0xaa4上。错误代码为0xc0000005。此错误可能是CLR中的bug，或者是用户代码的不安全部分或不可验证部分中的bug。此bug的常见来源包括用户对COM-interop或PInvoke的封送处理错误，这些错误可能会损坏堆栈。有时可能会报“读或者写受访问的内存”。而如果在调用前后设置断点，将不会参数异常。 c++ 函数定义 BOOL WINAPI DataEncryption(const BYTE* pszData, \ const BYTE* pszDispersionFactor,\ BYTE** pcResult); c#调用定义 bool DataEncryption（string encryptData,string dispFactor,ref string result); 如果使用以上定义，调...

2018-04-20

532

发表评论

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。