Spring和redis簡單測試demo

本文轉載自查看原文 2016-03-27 00:10 2918 spring/ maven/ mybatis/ redis

1.1 首先創建一個Maven工程

File --> New --> Other，然后選擇Maven目錄下的Maven Project，如下圖：

然后在彈出的面板中選擇配置后，下一步即可，如圖：

Create a simple project (skip archetype selection) ：此選項表示跳過后續的配置選項框。

Use default Workspace location：表示將項目放置到默認的工作區域下。

配置好后，Next下一步，再進行如下圖的配置：

點擊Finish后，便完成了Maven工程的創建。

此時在你開發工具的Workspace工作區的樹樁菜單中出現了SpringRedisStudy這個項目工程.如圖：

這時，工程會報錯，是因為一開始創建Maven工程時，選擇的是 Create a simple project 屬性，所以在webapp項目下可能會沒有任何文件，如圖：

這個時候就需要我們自己去創建它們。

首先在 webapp 下增加一個 WEB-INF 文件夾；然后在 WEB-INF 文件夾中增加一個 web.xml(部署描述符文件);

接下來我們就要在這個文件中進行一些配置工作。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app version="2.5" 
 3         xmlns="http://java.sun.com/xml/ns/javaee"
 4         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
 6                     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
 7     <display-name>SpringRedisStudy</display-name>
 8     <!-- 設置由Sprng載入的Log4j配置文件位置 -->
 9     <context-param>
10         <param-name>log4jConfigLocation</param-name>
11         <param-value>classpath:config/property/log4j.properties</param-value>
12     </context-param>
13     <!-- Spring刷新Log4j配置文件變動的間隔,單位為毫秒 -->
14     <context-param>
15         <param-name>log4jRefreshInterval</param-name>
16         <param-value>100000</param-value>
17     </context-param>
18     <!-- 加載其他配置文件至Spring應用上下文中 -->
19     <listener>
20         <listener-class>
21             org.springframework.web.context.ContextLoaderListener
22         </listener-class>
23     </listener>
24     <!-- 指定多個Spring配置文件 -->
25     <context-param>
26         <param-name>contextConfigLocation</param-name>
27         <param-value>
28             classpath:config/xml/dispatcher-servlet.xml;
29             classpath:config/xml/spring-context.xml
30         </param-value>
31     </context-param>
32     <!-- Spring字符集過濾器 -->
33     <filter>
34         <filter-name>SpringEncodingFilter</filter-name>
35         <filter-class>org.springframework.web.filter.CharacterEncodingFilter
36         </filter-class>
37         <init-param>
38             <param-name>encoding</param-name>
39             <param-value>UTF-8</param-value>
40         </init-param>
41         <init-param>
42             <param-name>forceEncoding</param-name>
43             <param-value>true</param-value>
44         </init-param>
45     </filter>
46     <filter-mapping>
47         <filter-name>SpringEncodingFilter</filter-name>
48         <url-pattern>/*</url-pattern>
49     </filter-mapping>
50 
51     <!-- Spring view分發器 -->
52     <!-- servlet-name 決定了初始化的名字:name-servlet.xml -->
53     <servlet>
54         <servlet-name>dispatcher</servlet-name>
55         <servlet-class>org.springframework.web.servlet.DispatcherServlet
56         </servlet-class>
57         <init-param>
58             <param-name>contextConfigLocation</param-name>
59             <param-value>/WEB-INF/classes/conf/dispatcher-servlet.xml
60             </param-value>
61         </init-param>
62         <load-on-startup>2</load-on-startup>
63     </servlet>
64     <servlet-mapping>
65         <servlet-name>dispatcher</servlet-name>
66         <url-pattern>/</url-pattern>
67     </servlet-mapping>
68 
69     <welcome-file-list>
70         <welcome-file>index.jsp</welcome-file>
71     </welcome-file-list>
72 
73 </web-app>

1.2 配置maven 工程文件 pom.xml

接下來我們進行詳細的項目搭建，首先配置maven 工程文件 pom.xml，

因為我們要搭建Spring MVC這個工程，所以就要將相關的jar包配置到Maven工程中進行引用管理；

pom.xml文件配置如下：

  1 <project xmlns="http://maven.apache.org/POM/4.0.0" 
  2         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  4             http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5     <modelVersion>4.0.0</modelVersion>
  6     <groupId>SpringRedisStudy</groupId>
  7     <artifactId>SpringRedisStudy</artifactId>
  8     <version>0.0.1-SNAPSHOT</version>
  9     <packaging>war</packaging>
 10     <properties>
 11         <!-- spring版本號 -->
 12         <org.springframework.version>3.0.7.RELEASE</org.springframework.version>
 13         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 14         <slf4j.version>1.7.5</slf4j.version>
 15         <log4j.version>1.2.17</log4j.version>
 16     </properties>
 17 
 18     <dependencies>
 19 
 20         <!-- config junit jar -->
 21         <dependency>
 22             <groupId>junit</groupId>
 23             <artifactId>junit</artifactId>
 24             <version>4.8.2</version>
 25             <scope>test</scope>
 26         </dependency>
 27 
 28         <!-- config redis data and client jar -->
 29         <dependency>
 30             <groupId>org.springframework.data</groupId>
 31             <artifactId>spring-data-redis</artifactId>
 32             <version>1.6.4.RELEASE</version>
 33         </dependency>
 34         <dependency>
 35             <groupId>redis.clients</groupId>
 36             <artifactId>jedis</artifactId>
 37             <version>2.7.3</version>
 38         </dependency>
 39         <dependency>
 40             <groupId>org.apache.commons</groupId>
 41             <artifactId>commons-pool2</artifactId>
 42             <version>2.4.2</version>
 43         </dependency>
 44 
 45         <!-- config need jar -->
 46         <dependency>
 47             <groupId>commons-lang</groupId>
 48             <artifactId>commons-lang</artifactId>
 49             <version>2.6</version>
 50         </dependency>
 51 
 52         <dependency>
 53             <groupId>org.apache.geronimo.specs</groupId>
 54             <artifactId>geronimo-servlet_3.0_spec</artifactId>
 55             <version>1.0</version>
 56         </dependency>
 57 
 58         <!-- cofig spring jar -->
 59         <dependency>
 60             <groupId>org.springframework</groupId>
 61             <artifactId>spring-core</artifactId>
 62             <version>${org.springframework.version}</version>
 63         </dependency>
 64 
 65         <dependency>
 66             <groupId>org.springframework</groupId>
 67             <artifactId>spring-expression</artifactId>
 68             <version>${org.springframework.version}</version>
 69         </dependency>
 70 
 71         <dependency>
 72             <groupId>org.springframework</groupId>
 73             <artifactId>spring-beans</artifactId>
 74             <version>${org.springframework.version}</version>
 75         </dependency>
 76 
 77         <dependency>
 78             <groupId>org.springframework</groupId>
 79             <artifactId>spring-aop</artifactId>
 80             <version>${org.springframework.version}</version>
 81         </dependency>
 82 
 83         <dependency>
 84             <groupId>org.springframework</groupId>
 85             <artifactId>spring-context</artifactId>
 86             <version>${org.springframework.version}</version>
 87         </dependency>
 88 
 89         <dependency>
 90             <groupId>org.springframework</groupId>
 91             <artifactId>spring-context-support</artifactId>
 92             <version>${org.springframework.version}</version>
 93         </dependency>
 94 
 95         <dependency>
 96             <groupId>org.springframework</groupId>
 97             <artifactId>spring-tx</artifactId>
 98             <version>${org.springframework.version}</version>
 99         </dependency>
100 
101         <dependency>
102             <groupId>org.springframework</groupId>
103             <artifactId>spring-jdbc</artifactId>
104             <version>${org.springframework.version}</version>
105         </dependency>
106 
107         <dependency>
108             <groupId>org.springframework</groupId>
109             <artifactId>spring-orm</artifactId>
110             <version>${org.springframework.version}</version>
111         </dependency>
112 
113         <dependency>
114             <groupId>org.springframework</groupId>
115             <artifactId>spring-oxm</artifactId>
116             <version>${org.springframework.version}</version>
117         </dependency>
118 
119         <dependency>
120             <groupId>org.springframework</groupId>
121             <artifactId>spring-web</artifactId>
122             <version>${org.springframework.version}</version>
123         </dependency>
124 
125         <dependency>
126             <groupId>org.springframework</groupId>
127             <artifactId>spring-webmvc</artifactId>
128             <version>${org.springframework.version}</version>
129         </dependency>
130 
131 
132         <dependency>
133             <groupId>org.springframework</groupId>
134             <artifactId>spring-webmvc-portlet</artifactId>
135             <version>${org.springframework.version}</version>
136         </dependency>
137 
138         <dependency>
139             <groupId>org.springframework</groupId>
140             <artifactId>spring-test</artifactId>
141             <version>${org.springframework.version}</version>
142             <scope>test</scope>
143         </dependency>
144         <!-- log start -->
145         <dependency>
146             <groupId>log4j</groupId>
147             <artifactId>log4j</artifactId>
148             <version>${log4j.version}</version>
149         </dependency>
150         <dependency>
151             <groupId>commons-logging</groupId>
152             <artifactId>commons-logging</artifactId>
153             <version>1.2</version>
154         </dependency>
155         <dependency>
156             <groupId>org.slf4j</groupId>
157             <artifactId>slf4j-api</artifactId>
158             <version>${slf4j.version}</version>
159         </dependency>
160         <dependency>
161             <groupId>org.slf4j</groupId>
162             <artifactId>slf4j-log4j12</artifactId>
163             <version>${slf4j.version}</version>
164         </dependency>
165         <!-- log end -->
166     </dependencies>
167 
168     <build>
169         <resources>
170             <resource>
171                 <directory>/src/main/resources</directory>
172                 <filtering>true</filtering>
173             </resource>
174         </resources>
175         <plugins>
176             <plugin>
177                 <artifactId>maven-war-plugin</artifactId>
178                 <configuration>
179                     <version>2.5</version>
180                 </configuration>
181             </plugin>
182         </plugins>
183     </build>
184 </project>

1.3 集成spring配置文件

Maven配置好后，我們就需要在項目中進行spring配置了；

在src/main/resources目錄中增加一個 config.xml包，並新建文件spring-context.xml；

這個文件的作用是配置Spring的，內容如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:mvc="http://www.springframework.org/schema/mvc" 
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xmlns:util="http://www.springframework.org/schema/util"
 8     xsi:schemaLocation="http://www.springframework.org/schema/beans 
 9     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
10       http://www.springframework.org/schema/context 
11       http://www.springframework.org/schema/context/spring-context-3.0.xsd  
12       http://www.springframework.org/schema/mvc 
13       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd          
14       http://www.springframework.org/schema/util 
15       http://www.springframework.org/schema/util/spring-util-3.0.xsd">
16     
17     <!-- 激活@Controller模式 -->
18     <mvc:annotation-driven />
19        <context:annotation-config />
20     <!-- 對包中的所有類進行掃描，以完成Bean創建和自動依賴注入的功能 需要更改 -->
21     <context:component-scan base-package="com.test.*" />
22     
23     <!-- 引入同文件夾下的redis屬性配置文件 -->
24     <import resource="redis-context.xml"/>
25     <!-- 測試用的userDao依賴注入 -->
26     <bean id="userDao" class="com.test.dao.impl.UserDao" /> 
27 </beans>

在該包config.xml下同時新建redis-context.xml文件，內容如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xmlns:context="http://www.springframework.org/schema/context"
 6     xsi:schemaLocation="
 7       http://www.springframework.org/schema/beans 
 8       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 9       http://www.springframework.org/schema/context
10       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
11 
12     <!-- 引入redis.properties配置文件 -->
13     <context:property-placeholder
14         location="classpath:/config/property/redis.properties" />
15     <!-- redis 相關配置 -->
16     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"
17         p:maxTotal="${redis.maxTotal}"
18         p:maxIdle="${redis.maxIdle}"
19         p:testOnBorrow="${redis.testOnBorrow}" />
20 
21     <bean id="connectionFactory"
22         class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
23         p:hostName="${redis.host}"
24         p:port="${redis.port}" 
25         p:password="${redis.password}"
26         p:database="${redis.database}"
27         p:pool-config-ref="poolConfig" />
28     <!-- redis template definition -->  
29     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
30         p:connectionFactory-ref="connectionFactory" 
31         p:keySerializer-ref="redisTemplateKeySerializer"
32         p:valueSerializer-ref="redisTemplateValueSerializer"
33         p:hashKeySerializer-ref="redisTemplateHashKeySerializer"
34         p:hashValueSerializer-ref="redisTemplateHashValueSerializer"/>
35     <bean id="redisTemplateKeySerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
36     <bean id="redisTemplateValueSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
37     <bean id="redisTemplateHashKeySerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
38     <bean id="redisTemplateHashValueSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
39 </beans>

在src/main/resources目錄中增加一個config.property包，並新建文件redis.properties，這個文件是redis的屬性配置文件，內容如下：

# Redis settings    
# server IP  
redis.host=127.0.0.1
# server port  
redis.port=6379  
redis.password=myredis
redis.maxTotal=600
#redis.maxActive=600   此屬性在新版本中不可用
# use dbIndex  
redis.database=0  
# 控制一個pool最多有多少個狀態為idle(空閑的)的jedis實例  
redis.maxIdle=300    
# 表示當borrow(引入)一個jedis實例時，最大的等待時間，如果超過等待時間(毫秒)，則直接拋出JedisConnectionException；  
#redis.maxWait=3000   此屬性在新版本中不可用   
# 在borrow一個jedis實例時，是否提前進行validate操作；如果為true，則得到的jedis實例均是可用的  
redis.testOnBorrow=true

在src/main/resources目錄下新建log4j.properties文件，作為log4j的屬性配置文件，內容如下：

#All level less than INFO will be logged
log4j.rootLogger=info,console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.ImmediateFlush=true
log4j.appender.console.Target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss}  %m%n

在項目工程未上線前暫時放在該目錄，方便測試，上線后可以移動到config.property目錄，此時需要在web.xml文件的<listener>節點前加入如下內容：

 1 ……    
 2         <display-name>SpringRedisStudy</display-name>
 3     <!-- 設置由Sprng載入的Log4j配置文件位置 -->
 4     <context-param>
 5         <param-name>log4jConfigLocation</param-name>
 6         <param-value>classpath:config/property/log4j.properties</param-value>
 7     </context-param>
 8     <!-- Spring刷新Log4j配置文件變動的間隔,單位為毫秒 -->
 9     <context-param>
10         <param-name>log4jRefreshInterval</param-name>
11         <param-value>100000</param-value>
12     </context-param>
13     <!-- 加載其他配置文件至Spring應用上下文中 -->
14     <listener>
15 ……

1.4 編寫java類

在SpringRedisStudy工程的src/main/java目錄下新建com.test.entity包，並新建User.java類，內容如下：

package com.test.entity;

import java.io.Serializable;

public class User implements Serializable{
	private static final long serialVersionUID = 8634600086311962551L;
	private String id;
  	private String name;
	public User() {
		super();
	}
	public User(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

在SpringRedisStudy工程的src/main/java目錄下新建com.test.dao包並在該包下新建抽象類AbstractBaseRedisDao.java和接口IUserDao.java文件，內容如下：

package com.test.dao;

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.data.redis.serializer.RedisSerializer;  
  
public abstract class AbstractBaseRedisDao <K, V> {  
      
    @Autowired  
    protected RedisTemplate<K, V> redisTemplate;
  
    /** 
     * 設置redisTemplate 
     * @param redisTemplate 給屬性redisTemplate賦值 
     */  
    public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }  
      
    /** 
     * 獲取 RedisSerializer 
     */  
    protected RedisSerializer<String> getRedisSerializer() {  
        return redisTemplate.getStringSerializer();  
    }  
}

package com.test.dao;

import java.util.List;  
import com.test.entity.User;  
  
public interface IUserDao {  
      
    /** 
     * 新增 
     * @param User對象 
     * @return 是否新增成功
     */  
    boolean add(User user);  
      
    /** 
     * 批量新增 使用pipeline方式 
     * @param list 
     * @return 是否新增成功
     */  
    boolean add(List<User> list);  
      
    /** 
     * 刪除 
     * @param key 
     */  
    void delete(String key);  
      
    /** 
     * 刪除多個 
     * @param keys 
     */  
    void delete(List<String> keys);  
      
    /** 
     * 修改 
     * @param user對象 
     * @return 是否修改成功
     */  
    boolean update(User user);  
  
    /** 
     * 通過key獲取User對象 
     * @param keyId 
     * @return User對象
     */  
    User get(String keyId);  
}

在SpringRedisStudy工程的src/main/java目錄下新建com.test.dao.impl包並在該包下新建接口的實現類UserDao.java文件，內容如下：

package com.test.dao.impl;

import java.util.ArrayList;  
import java.util.List;  
import org.springframework.dao.DataAccessException;  
import org.springframework.data.redis.connection.RedisConnection;  
import org.springframework.data.redis.core.RedisCallback;  
import org.springframework.data.redis.serializer.RedisSerializer;  
import org.springframework.util.Assert;  
import com.test.dao.AbstractBaseRedisDao;
import com.test.dao.IUserDao;
import com.test.entity.User;

public class UserDao extends AbstractBaseRedisDao <String, User> implements IUserDao {
    /** 
     * 新增 
     * @param User對象 
     * @return 是否新增成功
     */   
    public boolean add(final User user) {  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                byte[] key  = serializer.serialize(user.getId());
                byte[] name = serializer.serialize(user.getName());
                return connection.setNX(key, name);  
            }  
        });
        return result;  
    } 
    /** 
     * 批量新增 使用pipeline方式 
     * @param list 
     * @return 是否新增成功
     */  
    public boolean add(final List<User> list) {  
        Assert.notEmpty(list);  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            public Boolean doInRedis(RedisConnection connection)  
                    throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                for (User user : list) {  
                    byte[] key  = serializer.serialize(user.getId());  
                    byte[] name = serializer.serialize(user.getName());  
                    connection.setNX(key, name);  
                }  
                return true;  
            }  
        }, false, true);  
        return result;  
    }  
    /**  
     * 刪除 
     * @param key 
     */  
    public void delete(String key) { 
    	if (key ==null || key.length() == 0) {
			return;
		}
    	List<String> list = new ArrayList<String>();  
        list.add(key);  
        delete(list);
    }  
    /** 
     * 刪除多個 
     * @param keys 
     */  
    public void delete(List<String> keys) { 
        redisTemplate.delete(keys);  
    }  
    /** 
     * 修改  
     * @param user 
     * @return result 是否修改成功
     */  
    public boolean update(final User user) {  
        String key = user.getId();
        if (get(key) == null) {  
            throw new NullPointerException("數據行不存在, key = " + key);  
        }  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            public Boolean doInRedis(RedisConnection connection)  
                    throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                byte[] key  = serializer.serialize(user.getId());  
                byte[] name = serializer.serialize(user.getName());  
                connection.set(key, name);  
                return true;  
            }  
        });  
        return result;  
    }  
    /** 
     * 通過key獲取User對象 
     * @param keyId 
     * @return User對象
     */   
    public User get(final String keyId) {  
        User result = redisTemplate.execute(new RedisCallback<User>() {  
            public User doInRedis(RedisConnection connection)  
                    throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                byte[] key = serializer.serialize(keyId);  
                byte[] value = connection.get(key);  
                if (value == null) {  
                    return null;  
                }
                String name = serializer.deserialize(value); 
                return new User(keyId, name);
            }  
        });  
        return result;  
    }  

}

在SpringRedisStudy工程的src/test/java目錄的默認default包下新建測試類RedisTest.java文件，內容如下：

import java.util.ArrayList;  
import java.util.List;  
import junit.framework.Assert;  
import org.junit.Test;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
import com.test.dao.IUserDao;  
import com.test.entity.User;  
  
/**  
 * 測試 
 */    
@ContextConfiguration(locations = {"classpath:config/xml/spring-context.xml"})  
public class RedisTest extends AbstractJUnit4SpringContextTests {  
      
    @Autowired  
    private IUserDao userDao;
      
    /** 
     * 新增 
     */  
    @Test  
    public void testAddUser() {  
        User user = new User();  
        user.setId("user1");  
        user.setName("java2000_wl1");  
        boolean result = userDao.add(user);  
        Assert.assertTrue(result);  
    }  
     
    /** 
     * 批量新增 普通方式 
     */  
    @Test  
    public void testAddUsers1() {  
        List<User> list = new ArrayList<User>();  
        for (int i = 10; i < 50000; i++) {  
            User user = new User();  
            user.setId("user" + i);  
            user.setName("java2000_wl" + i);  
            list.add(user);  
        }  
        long begin = System.currentTimeMillis();  
        for (User user : list) {  
            userDao.add(user);  
        }  
        System.out.println(System.currentTimeMillis() -  begin);  
    }  
      
    /** 
     * 批量新增 pipeline方式 
     */  
    @Test  
    public void testAddUsers2() {  
        List<User> list = new ArrayList<User>();  
        for (int i = 50000; i < 100000; i++) {  
            User user = new User();  
            user.setId("user" + i);  
            user.setName("java2000_wl" + i);  
            list.add(user);  
        }  
        long begin = System.currentTimeMillis();  
        boolean result = userDao.add(list);  
        System.out.println(System.currentTimeMillis() - begin);  
        Assert.assertTrue(result);  
    }  
       
    /** 
     * 修改 
     */  
    @Test  
    public void testUpdate() {  
        User user = new User();  
        user.setId("user1");  
        user.setName("new_password");  
        boolean result = userDao.update(user);  
        Assert.assertTrue(result);  
    }  
    /** 
     * 獲取 
     */  
    @Test  
    public void testGetUser() {  
        String id = "user1";  
        User user = userDao.get(id);  
        Assert.assertNotNull(user);  
        Assert.assertEquals(user.getName(), "java2000_wl1");  
    }       
    /** 
     * 通過key刪除單個 
     */  
    @Test  
    public void testDelete() {  
        String key = "user1";  
        userDao.delete(key);  
    }  
      
    /** 
     * 批量刪除 
     */  
    @Test  
    public void testDeletes() {  
        List<String> list = new ArrayList<String>();  
        for (int i = 0; i < 100000; i++) {  
            list.add("user" + i);  
        }  
        userDao.delete(list);  
    }  

    /** 
     * 設置userDao 
     * @param userDao the userDao to set 
     */  
    public void setUserDao(IUserDao userDao) {  
        this.userDao = userDao;  
    }  
}

1.5 測試

在RedisTest.java文件上右鍵run as --->Run Configurations，開始測試：

測試結果：

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Spring Boot超簡單的測試類demo Spring的簡單demo spring mvc 3 最簡單demo Redis - springboot操作redis的簡單demo spring batch 學習簡單demo spring集成hbase,簡單的demo Spring環境搭建及簡單demo [spring boot] 03 簡單demo_1 - 編寫mapper,dao,service和單元測試 Redis簡單本機測試簡單的redis測試