spring boot:spring mvc + spring + redis + mybatis(maven构建)

1、先上pom.xml文件文件里面都有注解

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0"
  3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5     <modelVersion>4.0.0</modelVersion>
  6 
  7     <groupId>com.bbkj.isl.nurse</groupId>
  8     <artifactId>nurse_person</artifactId>
  9     <packaging>war</packaging>
 10     <version>1.0-SNAPSHOT</version>
 11     <name>nurse Maven Webapp</name>
 12     <url>http://maven.apache.org</url>
 13 
 14     <!--继承Spring Boot starter parent-->
 15     <parent>
 16         <groupId>org.springframework.boot</groupId>
 17         <artifactId>spring-boot-starter-parent</artifactId>
 18         <version>1.5.1.RELEASE</version>
 19     </parent>
 20 
 21     <properties>
 22         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 23         <!-- junit -->
 24         <junit.version>4.12</junit.version>
 25         <servlet.version>3.1.0</servlet.version>
 26         <!-- spring -->
 27         <spring.version>4.3.6.RELEASE</spring.version>
 28         <!-- container -->
 29         <jetty.version>9.3.0.M2</jetty.version>
 30         <spring.mybatis.version>1.2.2</spring.mybatis.version>
 31 
 32         <spring-data-mongodb.version>1.7.2.RELEASE</spring-data-mongodb.version>
 33         <mongo-java-driver.version>3.0.2</mongo-java-driver.version>
 34         <!-- db -->
 35         <mysql.version>5.1.34</mysql.version>
 36         <mybatis.version>3.4.4</mybatis.version>
 37         <druid.version>1.0.13</druid.version>
 38         <!-- for slf4j conflict -->
 39         <empty.version>empty</empty.version>
 40         <slf4j.version>1.7.5</slf4j.version>
 41         <mybatis-spring-boot>1.3.0</mybatis-spring-boot>
 42     </properties>
 43     <dependencies>
 44         <dependency>
 45             <groupId>junit</groupId>
 46             <artifactId>junit</artifactId>
 47             <version>4.12</version>
 48             <scope>test</scope>
 49         </dependency>
 50         <dependency>
 51             <groupId>org.testng</groupId>
 52             <artifactId>testng</artifactId>
 53             <version>6.11</version>
 54         </dependency>
 55         <!--Spring Boot-->
 56         <!-- Spring Boot 核心三个模块 START -->
 57         <!-- 核心模块,包括自动配置支持、日志和YAML -->
 58         <dependency>
 59             <groupId>org.springframework.boot</groupId>
 60             <artifactId>spring-boot-starter</artifactId>
 61             <exclusions>
 62                 <!-- 排除默认日志框架 spring boot 1.4.X默认日志框架为 SLF4J+Logback,这里先排除 -->
 63                 <exclusion>
 64                     <groupId>org.springframework.boot</groupId>
 65                     <artifactId>spring-boot-starter-logging</artifactId>
 66                 </exclusion>
 67             </exclusions>
 68         </dependency>
 69         <!--支持 Web 应用开发,包含 Tomcat 和 spring-mvc。 -->
 70         <dependency>
 71             <groupId>org.springframework.boot</groupId>
 72             <artifactId>spring-boot-starter-web</artifactId>
 73             <exclusions>
 74                 <exclusion>
 75                     <groupId>commons-logging</groupId>
 76                     <artifactId>commons-logging</artifactId>
 77                 </exclusion>
 78                 <exclusion>
 79                     <groupId>org.springframework.boot</groupId>
 80                     <artifactId>spring-boot-starter-tomcat</artifactId>
 81                 </exclusion>
 82             </exclusions>
 83         </dependency>
 84         <!-- 排除Tomcat,使用jetty -->
 85         <dependency>
 86             <groupId>org.springframework.boot</groupId>
 87             <artifactId>spring-boot-starter-jetty</artifactId>
 88         </dependency>
 89          <!--devtools:是spring boot的一个热部署工具-->
 90         <dependency>
 91             <groupId>org.springframework.boot</groupId>
 92             <artifactId>spring-boot-devtools</artifactId>
 93             <optional>true</optional>
 94         </dependency>
 95         <!--支持使用 JDBC 访问数据库-->
 96         <dependency>
 97             <groupId>org.springframework.boot</groupId>
 98             <artifactId>spring-boot-starter-jdbc</artifactId>
 99         </dependency>
100         <dependency>
101             <groupId>org.springframework.boot</groupId>
102             <artifactId>spring-boot-starter-data-redis</artifactId>
103         </dependency>
104         <dependency>
105             <groupId>org.springframework.boot</groupId>
106             <artifactId>spring-boot-starter-websocket</artifactId>
107         </dependency>
108         <dependency>
109             <groupId>org.springframework.boot</groupId>
110             <artifactId>spring-boot-starter-test</artifactId>
111             <exclusions>
112                 <exclusion>
113                     <groupId>commons-logging</groupId>
114                     <artifactId>commons-logging</artifactId>
115                 </exclusion>
116             </exclusions>
117         </dependency>
118         <dependency>
119             <groupId>org.springframework.boot</groupId>
120             <artifactId>spring-boot-starter-aop</artifactId>
121         </dependency>
122         <dependency>
123             <groupId>org.springframework.boot</groupId>
124             <artifactId>spring-boot-starter-amqp</artifactId>
125         </dependency>
126         <!--添加适用于生产环境的功能,如性能指标和监测等功能。 -->
127         <dependency>
128             <groupId>org.springframework.boot</groupId>
129             <artifactId>spring-boot-starter-actuator</artifactId>
130         </dependency>
131         <dependency>
132             <groupId>org.springframework.boot</groupId>
133             <artifactId>spring-boot-starter-logging</artifactId>
134             <scope>runtime</scope>
135         </dependency>
136         <!-- Spring Boot Mybatis 依赖 -->
137         <dependency>
138             <groupId>org.mybatis.spring.boot</groupId>
139             <artifactId>mybatis-spring-boot-starter</artifactId>
140             <version>${mybatis-spring-boot}</version>
141             <exclusions>
142                 <exclusion>
143                     <groupId>org.apache.tomcat</groupId>
144                     <artifactId>tomcat-jdbc</artifactId>
145                 </exclusion>
146                 <!-- <exclusion> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> </exclusion> -->
147             </exclusions>
148         </dependency>
149 
150         <dependency>
151             <groupId>org.springframework</groupId>
152             <artifactId>spring-messaging</artifactId>
153             <version>${spring.version}</version>
154         </dependency>
155         <!-- slf4j -->
156         <dependency>
157             <groupId>org.slf4j</groupId>
158             <artifactId>slf4j-api</artifactId>
159             <version>${slf4j.version}</version>
160         </dependency>
161         <dependency>
162             <groupId>org.slf4j</groupId>
163             <artifactId>jcl-over-slf4j</artifactId>
164             <version>${slf4j.version}</version>
165         </dependency>
166         <dependency>
167             <groupId>org.slf4j</groupId>
168             <artifactId>slf4j-log4j12</artifactId>
169             <version>1.7.11</version>
170             <scope>provided</scope>
171         </dependency>
172         <dependency>
173             <groupId>org.slf4j</groupId>
174             <artifactId>log4j-over-slf4j</artifactId>
175             <version>1.7.7</version>
176         </dependency>
177         <dependency>
178             <groupId>commons-logging</groupId>
179             <artifactId>commons-logging</artifactId>
180             <version>1.2</version>
181             <scope>provided</scope>
182         </dependency>
183         <dependency>
184             <groupId>commons-io</groupId>
185             <artifactId>commons-io</artifactId>
186             <version>2.4</version>
187         </dependency>
188         <dependency>
189             <groupId>commons-lang</groupId>
190             <artifactId>commons-lang</artifactId>
191             <version>2.6</version>
192         </dependency>
193 
194         <dependency>
195             <groupId>com.alibaba</groupId>
196             <artifactId>fastjson</artifactId>
197             <version>1.2.8</version>
198         </dependency>
199         <!-- 数据库连接池 -->
200         <dependency>
201             <groupId>com.alibaba</groupId>
202             <artifactId>druid</artifactId>
203             <version>${druid.version}</version>
204         </dependency>
205 
206         <dependency>
207             <groupId>org.apache.httpcomponents</groupId>
208             <artifactId>httpclient</artifactId>
209             <version>4.5.1</version>
210         </dependency>
211         <dependency>
212             <groupId>org.apache.httpcomponents</groupId>
213             <artifactId>httpasyncclient</artifactId>
214             <version>4.1</version>
215         </dependency>
216         <dependency>
217             <groupId>mysql</groupId>
218             <artifactId>mysql-connector-java</artifactId>
219             <version>${mysql.version}</version>
220         </dependency>
221         <dependency>
222             <groupId>redis.clients</groupId>
223             <artifactId>jedis</artifactId>
224             <version>2.9.0</version>
225         </dependency>
226 
227         <!-- websocket -->
228         <dependency>
229             <groupId>javax.websocket</groupId>
230             <artifactId>javax.websocket-api</artifactId>
231             <version>1.0</version>
232         </dependency>
233 
234         <!-- https://mvnrepository.com/artifact/com.google.zxing/core -->
235         <dependency>
236             <groupId>com.google.zxing</groupId>
237             <artifactId>core</artifactId>
238             <version>3.2.0</version>
239         </dependency>
240         <!--二维码-->
241     </dependencies>
242     <build>
243         <finalName>nurse_person</finalName>
244         <plugins>
245             <!-- maven 打包的时候指定启动时的主类 -->
246             <plugin>
247                 <groupId>org.springframework.boot</groupId>
248                 <artifactId>spring-boot-maven-plugin</artifactId>
249                 <configuration>
250                     <mainClass>com.bbkj.isl.person.nurse.Application</mainClass>
251                 </configuration>
252             </plugin>
253             <plugin>
254                 <groupId>org.apache.maven.plugins</groupId>
255                 <artifactId>maven-compiler-plugin</artifactId>
256                 <version>3.0</version>
257                 <configuration>
258                     <source>1.8</source>
259                     <target>1.8</target>
260                     <encoding>utf-8</encoding>
261                 </configuration>
262             </plugin>
263             <!-- maven 整理resurce -->
264             <plugin>
265                 <groupId>org.apache.maven.plugins</groupId>
266                 <artifactId>maven-resources-plugin</artifactId>
267                 <version>2.7</version>
268                 <configuration>
269                     <encoding>UTF-8</encoding>
270                 </configuration>
271             </plugin>
272             <plugin>
273                 <groupId>org.apache.maven.plugins</groupId>
274                 <artifactId>maven-surefire-plugin</artifactId>
275                 <version>2.18.1</version>
276                 <configuration>
277                     <includes>
278                         <include>**/*Test.java</include>
279                     </includes>
280                 </configuration>
281             </plugin>
282             
283         </plugins>
284         <!-- maven filter 作用是使用build(自己建的目录) 下的多环境配置 的参数值 替换导resource 文件目录下的 实际代码用到的配置中去 -->
285         <filters>
286             <filter>${basedir}/build/${environment}.properties</filter>
287         </filters>
288         <resources>
289             <resource>
290                 <directory>${basedir}/src/main/resources</directory>
291                 <includes>
292                     <include>**/*</include>
293                     <include>*</include>
294                 </includes>
295             </resource>
296             <resource>
297                 <directory>${basedir}/src/main/resources</directory>
298                 <includes>
299                     <include>*.properties</include>
300                     <!--<include>logback.xml</include>-->
301                 </includes>
302                 <filtering>true</filtering>
303             </resource>
304         </resources>
305     </build>
306     <!-- 多种运行环境配置 -->
307     <profiles>
308         <profile>
309             <id>dev</id>
310             <properties>
311                 <environment>dev</environment>
312             </properties>
313             <activation>
314                 <os>
315                     <family>unix</family>
316                 </os>
317                 <activeByDefault>true</activeByDefault>
318             </activation>
319         </profile>
320         <profile>
321             <id>dev-win</id>
322             <properties>
323                 <environment>dev-win</environment>
324             </properties>
325             <activation>
326                 <os>
327                     <family>windows</family>
328                 </os>
329                 <activeByDefault>true</activeByDefault>
330             </activation>
331         </profile>
332         <profile>
333             <id>test</id>
334             <properties>
335                 <environment>test</environment>
336             </properties>
337         </profile>
338         <profile>
339             <id>product</id>
340             <properties>
341                 <environment>product</environment>
342             </properties>
343         </profile>
344     </profiles>
345 
346 </project>
View Code

2、resource目录:

mapper是mybatis 的mapper 的文件,相信用过mybatis 的都知道是什么格式的:如下给个例子文件(这是调用微信用户信息获取到的数据内容的一张表)

<?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.bbkj.isl.person.nurse.wechat.api.user.dao.UserMapper" >
  <resultMap id="BaseResultMap" type="com.bbkj.isl.person.nurse.wechat.api.user.entity.User" >
    <id column="id" property="id" jdbcType="BIGINT" />
    <result column="subscribe" property="subscribe" jdbcType="TINYINT" />
    <result column="openid" property="openid" jdbcType="VARCHAR" />
    <result column="nickname" property="nickname" jdbcType="VARCHAR" />
    <result column="sex" property="sex" jdbcType="TINYINT" />
    <result column="city" property="city" jdbcType="VARCHAR" />
    <result column="country" property="country" jdbcType="VARCHAR" />
    <result column="province" property="province" jdbcType="VARCHAR" />
    <result column="language" property="language" jdbcType="VARCHAR" />
    <result column="headimgurl" property="headimgurl" jdbcType="VARCHAR" />
    <result column="subscribe_time" property="subscribeTime" jdbcType="BIGINT" />
    <result column="unionid" property="unionid" jdbcType="VARCHAR" />
    <result column="remark" property="remark" jdbcType="VARCHAR" />
    <result column="groupid" property="groupid" jdbcType="INTEGER" />
    <result column="create_time" property="createTime" jdbcType="BIGINT" />
    <result column="update_time" property="updateTime" jdbcType="BIGINT" />
  </resultMap>
  <sql id="Base_Column_List" >
    id, subscribe, openid, nickname, sex, city, country, province, language, headimgurl, 
    subscribe_time, unionid, remark, groupid, create_time, update_time
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Long" >
    select
    <include refid="Base_Column_List" />
    from user
    where id = #{id,jdbcType=BIGINT}
  </select>
</mapper>

 

还有一个application.properties:这里是redis、mybatis、database的配置信息

# REDIS (RedisProperties)
spring.redis.database=0
spring.redis.host=@redis.ip@
spring.redis.port=@redis.port@
spring.redis.pool.max-active=@redis.pool.maxActive@
spring.redis.pool.max-wait=@redis.pool.maxWait@
spring.redis.pool.max-idle=@redis.pool.maxIdle@
spring.redis.timeout=@redis.timeout@

#log path
logging.path=@log.path@
logging.level.*=@log.level@

#db 10.248.248.6
spring.datasource.driver-class-name=@db.driver@
spring.datasource.type=@db.type@
spring.datasource.url=@db.url@
spring.datasource.username=@db.username@
spring.datasource.password=@db.password@
spring.datasource.initial-size=@db.initialSize@
spring.datasource.max-active=@db.maxActive@
spring.datasource.min-idle={db.minIdle@
spring.datasource.max-wait-millis=@db.maxWait@
spring.datasource.test-while-idle=@db.testWhileIdle@
spring.datasource.test-on-borrow=@db.testOnBorrow@
spring.datasource.test-on-return=@db.testOnReturn@
spring.datasource.time-between-eviction-runsMillis=@db.timeBetweenEvictionRunsMillis@
spring.datasource.min-evictable-idle-time-millis=@db.minEvictableIdleTimeMillis@
spring.datasource.validation-query=@db.validationQuery@
spring.datasource.remove-abandoned=@db.removeAbandoned@
spring.datasource.remove-abandoned-timeout=@db.removeAbandonedTimeout@
spring.datasource.log-abandoned=@db.logAbandoned@

#可以不配置
#mybatis.config-locations=@mybatis.config-locations@
mybatis.mapper-locations=@mybatis.mapper-locations@
#可以不配置
#mybatis.type-aliases-package=@com.bbkj.isl.person.nurse.wechat.**.entity@


#weixin
weixin.appId=@weixin.appId@
weixin.appSecret=@weixin.appSecret@
weixin.focus.qrcode=@weixin.focus.qrcode@

注意:这个文件有一个和我们以往使用的配置文件属性赋值不同的地方是。这里是这种@.......@“”方式,而不是“${......}”

那个这个文件对应的dui文件配置的build目录下的properties如下:

#environment 1=dev,2=test,3=prd
env=1


#log path
log.path=/data/logs/nurse
log.level=info


db.type=com.alibaba.druid.pool.DruidDataSource
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://10.248.248.28:3306/bbkj_wechat_person?characterEncoding=UTF-8&useUnicode=true&connectTimeout=10000&\
  socketTimeout=10000&autoReconnect=true&maxReconnects=5&failOverReadOnly=false&zeroDateTimeBehavior=convertToNull
db.username=*****
db.password=*****
db.initialSize=10
db.maxActive=20
db.minIdle=10
db.maxWait=60000
db.defaultAutoCommit=true
db.testWhileIdle=true
db.testOnBorrow=true
db.testOnReturn=true
db.timeBetweenEvictionRunsMillis=3600000
db.minEvictableIdleTimeMillis=3600000
db.validationQuery=SELECT 1
db.removeAbandoned=true
db.removeAbandonedTimeout=300
db.logAbandoned=true

#redis
redis.ip=10.248.248.28
redis.port=6379
redis.pool.maxActive=1024
redis.pool.maxIdle=10
redis.pool.maxWait=10000
redis.pool.testOnBorrow=false
redis.timeout=10000

#weixin
weixin.appId=*********
weixin.appSecret=***********
weixin.focus.qrcode=*********

#可以不配置
#mybatis.config-locations=classpath:mybatis/mybatis-config.xml
mybatis.mapper-locations=classpath:mapper/*.xml
#可以不配置
#mybatis.type-aliases-package=com.bbkj.isl.person.nurse.wechat.**.entity

然后这个文件可以根据不同的环境建立多个:

3、spring 启动类:

package com.bbkj.isl.person.nurse;

import org.apache.log4j.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

/**
 * Created by Administrator on 2017/7/6.
 */
@SpringBootApplication
//@MapperScan("com.bbkj.isl.person.nurse.wechat.**.dao") //指定mybatis mapper 文件 所在目录 可以不配置
public class Application extends SpringBootServletInitializer {

    private static Logger logger = Logger.getLogger(Application.class);
    @Autowired
    private RedisOperateImp redisOperateImp;

    /**
     * war 包部署时 代替web.xml
     * @param application
     * @return
     */
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }

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

4、reids

package com.bbkj.isl.person.nurse.cache;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Created by Administrator on 2017/7/6.
 */
@Configuration
public class RedisConfiguration {

    @Bean(name= "jedis.pool")
    @Autowired
    public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config,
                               @Value("${spring.redis.host}")String host,
                               @Value("${spring.redis.port}")int port) {
        return new JedisPool(config, host, port);
    }

    @Bean(name= "jedis.pool.config")
    public JedisPoolConfig jedisPoolConfig (@Value("${spring.redis.pool.max-active}")int maxTotal,
                                            @Value("${spring.redis.pool.max-idle}")int maxIdle,
                                            @Value("${spring.redis.pool.max-wait}")int maxWaitMillis) {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxTotal);
        config.setMaxIdle(maxIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        return config;
    }
}
package com.bbkj.isl.person.nurse.cache;

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


public interface RedisOperate {

    void set(String key, String value);

    void set(String key, String value, int second);

    void createCountKey(String key, int value);

    void del(String key);

    String getStringByKey(String key);

    /**
     * 计数
     */
    void keyDecrement(String key, int step);

    void keyIncrement(String key, int step);

    /**
     * set
     */
    void setAdd(String key, String value);

    void setDel(String key, String value);

    Set<String> getSetMember(String key);

    long getSetSize(String key);

    /**
     * zset
     */
    void zsetAdd(String key, long score, String value);

    void zsetDel(String key, String value);

    long getZsetSize(String key);

    Set<String> getZsetByscoreByPage(String key, String min, String max, int offset, int count);

    Set<String> getZsetByScore(String key, String min, String max);

    long zsetRemrangebyScore(String key, String min, String max);

    /**
     * list
     */
    void listAdd(String key, String value);

    List<String> getListAll(String key, int start, int stop);

    void listRangeDel(String key, int start, int stop);

    long listDelByValue(String key, long count, String value);

    /**
     * hash
     */
    String hmset(String key, Map<String, String> map);

    long hincrby(String key, String field, long step);

    String hget(String key, String field);

    Map<String, String> hgetall(String key);

    //add new
    List<String> hvals(String key); //返回名称为key的hash中所有键对应的value

    Long hdel(String key, String field); //删除名称为key的hash中键为field的域

    Long hset(String key, String field, String value);      //向名称为key的hash中添加元素field<—>value


    /**
     * 事务处理
     */
    List<Object> getZsetByScoreAndRemove(String key, String min, String max);

    /**
     * 设置key过期时间
     */
    long setExpire(String key, int seconds);

    Set<String> keys(String pattern);

    void delKeys(String pattern);

    /**
     * 获取redis服务器时间
     */
    List<String> getTime();
}
package com.bbkj.isl.person.nurse.cache;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Transaction;

import javax.annotation.Resource;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


@Repository
public class RedisOperateImp implements RedisOperate {

    private static final Logger Logger = LoggerFactory.getLogger(RedisOperateImp.class);

    @Resource
    private RedisPool redispool;

    public void set(String key, String value) {
        Jedis con = redispool.getConnection();
        try {
            con.set(key, value);
        } finally {
            redispool.closeConnection(con);
        }
    }

    public void set(String key, String value, int second) {
        Jedis con = redispool.getConnection();
        con.set(key, value);
        con.expire(key, second);
        redispool.closeConnection(con);
    }

    public void createCountKey(String key, int value) {
        Jedis con = redispool.getConnection();
        con.set(key, new Integer(value).toString());
        redispool.closeConnection(con);
    }

    public void del(String key) {
        Jedis con = redispool.getConnection();
        if (con != null) {
            con.del(key);
        }
        redispool.closeConnection(con);
    }

    public String getStringByKey(String key) {
        Jedis con = redispool.getConnection();
        String res = con.get(key);
        redispool.closeConnection(con);
        return res;
    }

    public void keyDecrement(String key, int step) {
        Jedis con = redispool.getConnection();
        con.decrBy(key, step);
        redispool.closeConnection(con);
    }

    public void keyIncrement(String key, int step) {
        Jedis con = redispool.getConnection();
        con.incrBy(key, step);
        redispool.closeConnection(con);
    }

    public void setAdd(String key, String value) {
        Jedis con = redispool.getConnection();
        con.sadd(key, value);
        redispool.closeConnection(con);
    }

    public void setDel(String key, String value) {
        Jedis con = redispool.getConnection();
        con.srem(key, value);
        redispool.closeConnection(con);
    }

    public Set<String> getSetMember(String key) {
        Jedis con = redispool.getConnection();
        Set<String> set = con.smembers(key);
        redispool.closeConnection(con);
        return set;
    }

    public long getSetSize(String key) {
        Jedis con = redispool.getConnection();
        long size = con.scard(key);
        redispool.closeConnection(con);
        return size;
    }

    public void zsetAdd(String key, long score, String value) {
        Jedis con = redispool.getConnection();
        con.zadd(key, score, value);
        redispool.closeConnection(con);
    }

    public void zsetDel(String key, String value) {
        Jedis con = redispool.getConnection();
        con.zrem(key, value);
        redispool.closeConnection(con);
    }

    public long getZsetSize(String key) {
        Jedis con = redispool.getConnection();
        long size = con.zcard(key);
        redispool.closeConnection(con);
        return size;
    }

    public Set<String> getZsetByscoreByPage(String key, String min, String max,
                                            int offset, int count) {
        Jedis con = redispool.getConnection();
        Set<String> sets = con.zrangeByScore(key, min, max, offset, count);
        redispool.closeConnection(con);
        return sets;
    }

    @Override
    public Set<String> getZsetByScore(String key, String min, String max) {

        Jedis con = redispool.getConnection();
        Set<String> sets = con.zrangeByScore(key, min, max);
        redispool.closeConnection(con);
        return sets;
    }

    @Override
    public long zsetRemrangebyScore(String key, String min, String max) {
        Jedis con = redispool.getConnection();
        long size = con.zremrangeByScore(key, min, max);
        redispool.closeConnection(con);
        return size;
    }

    public void listAdd(String key, String value) {
        Jedis con = redispool.getConnection();
        con.lpush(key, value);
        redispool.closeConnection(con);
    }

    public List<String> getListAll(String key, int start, int stop) {
        Jedis con = redispool.getConnection();
        List<String> list = con.lrange(key, start, stop);
        redispool.closeConnection(con);
        return list;
    }

    public void listRangeDel(String key, int start, int stop) {
        Jedis con = redispool.getConnection();
        con.ltrim(key, start, stop);
        redispool.closeConnection(con);
    }

    @Override
    public long listDelByValue(String key, long count, String value) {
        Jedis con = redispool.getConnection();
        long amount = con.lrem(key, count, value);
        redispool.closeConnection(con);
        return amount;
    }

    @Override
    public String hmset(String key, Map<String, String> map) {
        Jedis con = redispool.getConnection();
        String res = con.hmset(key, map);
        redispool.closeConnection(con);
        return res;
    }

    @Override
    public long hincrby(String key, String field, long step) {
        Jedis con = redispool.getConnection();
        long size = con.hincrBy(key, field, step);
        redispool.closeConnection(con);
        return size;
    }

    @Override
    public String hget(String key, String field) {
        Jedis con = redispool.getConnection();
        String res = con.hget(key, field);
        redispool.closeConnection(con);
        return res;
    }

    @Override
    public Map<String, String> hgetall(String key) {
        Jedis con = redispool.getConnection();
        Map<String, String> res = con.hgetAll(key);
        redispool.closeConnection(con);
        return res;
    }

    @Override
    public List<String> hvals(String key) {
        Jedis con = redispool.getConnection();
        List<String> hvals = con.hvals(key);
        redispool.closeConnection(con);
        return hvals;
    }

    @Override
    public Long hdel(String key, String field) {
        Jedis con = redispool.getConnection();
        Long hdel = con.hdel(key, field);
        redispool.closeConnection(con);
        return hdel;
    }

    @Override
    public Long hset(String key, String field, String value) {
        Jedis con = redispool.getConnection();
        Long hset = con.hset(key, field,value);
        redispool.closeConnection(con);
        return hset;
    }

    @Override
    public List<Object> getZsetByScoreAndRemove(String key, String min, String max) {
        Jedis con = redispool.getConnection();
        Transaction tx = con.multi();
        tx.zrangeByScore(key, min, max);
        tx.zremrangeByScore(key, min, max);
        List<Object> res = tx.exec();
        return res;
    }

    @Override
    public long setExpire(String key, int seconds) {
        Jedis con = redispool.getConnection();
        Long expire = con.expire(key, seconds);
        redispool.closeConnection(con);
        return expire;
    }

    @Override
    public Set<String> keys(String pattern) {
        Jedis con = redispool.getConnection();
        Set<String> keys = con.keys(pattern);
        Transaction tx = con.multi();
        List<Object> list = tx.exec();
        redispool.closeConnection(con);
        return keys;
    }

    @Override
    public void delKeys(String pattern) {
        Jedis con = redispool.getConnection();
        Set<String> keys = con.keys(pattern);
        if(null != keys && keys.size() > 0) {
            Pipeline pipeline = con.pipelined();
            Iterator<String> it = keys.iterator();
            while (it.hasNext()) {
                String key = it.next();
                pipeline.del(key);
            }
            pipeline.sync();
        }
        redispool.closeConnection(con);
    }

    @Override
    public List<String> getTime() {
        Jedis con = redispool.getConnection();
        List<String> time = con.time();
        redispool.closeConnection(con);
        return time;
    }
}
View Code
package com.bbkj.isl.person.nurse.cache;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisException;

import javax.annotation.Resource;


@Repository
public class RedisPool {

    private static final Logger Logger = LoggerFactory.getLogger(RedisPool.class);

    @Resource
    private JedisPool pool;

    public Jedis getConnection() {
        Jedis con = null;
        try {
            con = pool.getResource();
        } catch (JedisConnectionException e) {
            throw e;
            //Todo 监控
        }
        return con;
    }

    public void closeConnection(Jedis con) {

        try {
            pool.returnResource(con);
        } catch (JedisException e) {
            throw e;
            //TODO 监控
        }
    }
}
View Code

 

有了这些做基础,那么spring boot 基本上就搭建好了。

下面写一个例子:

Controller层:

package com.bbkj.isl.person.nurse.wechat.api.user.controller;


import com.bbkj.isl.person.nurse.common.ApiResult;
import com.bbkj.isl.person.nurse.wechat.api.user.controller.vi.UserVI;
import com.bbkj.isl.person.nurse.wechat.api.user.entity.User;
import com.bbkj.isl.person.nurse.wechat.api.user.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 *
 * Created by Administrator on 2017/2/28.
 */
@RestController
@RequestMapping("/user")
public class UserController {


    private  static final Logger logger= LoggerFactory.getLogger(UserController.class);


    @Autowired
    private UserService userService;

    @RequestMapping(value="/list"
            ,consumes = "application/json"
            ,produces = "application/json;chartset=utf-8")
    public ApiResult<User> getPatientList(@RequestBody UserVI userVI){
        ApiResult<User> apiResult = new ApiResult<>(0,"success");
        try{
            User user=userService.selectByKey(userVI.getOpenid());
        }catch (Exception e){
            logger.error("",e);
            apiResult.setCode(1);
            apiResult.setMessage("服务器内部错误");
        }
        return apiResult;
    }
}

 

@Service层

package com.bbkj.isl.person.nurse.wechat.api.user.service;


import com.bbkj.isl.person.nurse.wechat.api.user.entity.User;

public interface UserService {


    User selectByKey(String openid);
}
View Code
package com.bbkj.isl.person.nurse.wechat.api.user.service.impl;

import com.bbkj.isl.person.nurse.wechat.api.user.dao.UserMapper;
import com.bbkj.isl.person.nurse.wechat.api.user.entity.User;
import com.bbkj.isl.person.nurse.wechat.api.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;
   

    @Override
    public User selectByKey(String openid) {
        return userMapper.selectByKey(openid);
    }

}
View Code

@Dao 层

package com.bbkj.isl.person.nurse.wechat.api.user.dao;


import org.apache.ibatis.annotations.Mapper;
import com.bbkj.isl.person.nurse.wechat.api.user.entity.User;

@Mapper//加入mapper 注解 才能注入spring bean 
public interface UserMapper {

    User selectByKey(String openid);

}

Mapper.xml

  <select id="selectByKey" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from user
    where openid = #{openid,jdbcType=VARCHAR}

  </select>

好了至此,所有带么开发完毕。

部署:

根据pom.xml那边配置的是打包成war包

使用:mvn clean package -Pdev 即可使用dev.properties文件里的配置打包

然后这个war 可以放入tomcat 或者 jetty中即可。

 

posted @ 2017-07-07 20:58  Enast  阅读(394)  评论(0)    收藏  举报