常用框架(二) : spring+springMvc+mybatis+maven+redis

最新推荐文章于 2024-07-31 08:30:09 发布
最新推荐文章于 2024-07-31 08:30:09 发布
阅读量5k 收藏 11
点赞数 2
分类专栏： 项目框架 文章标签： spring redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MyNoteBlog/article/details/54927491
版权

在上一篇常用框架(一)中已经搭建好了基本框架，这里主要是集成 redis 缓存框架到项目中，作为补充。

需要查看前篇的请点这里跳转：http://blog.csdn.net/mynoteblog/article/details/54922775

先来看下项目结构：


一，在pom.xml 中追加redis依赖包，由于改动比较多，这里还是直接贴上全部内容，以免遗漏：

<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/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.maven.web</groupId>
	<artifactId>com.maven.web</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>com.maven.web Maven Webapp</name>

	<properties>
		<spring.version>4.3.0.RELEASE</spring.version>
		<jackson.version>2.6.5</jackson.version>
		<fastjson.version>1.2.23</fastjson.version>
		<mybatis.version>3.3.0</mybatis.version>
		<mybatis-spring.version>1.2.3</mybatis-spring.version>
		<mysql.connector.version>5.1.29</mysql.connector.version>
		<jedis.version>2.7.3</jedis.version>
	    <spring.data.redis.version>1.7.1.RELEASE</spring.data.redis.version>
	</properties>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/libs-milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<!-- @Resource注解包 -->
		<dependency>
			<groupId>javax.annotation</groupId>
			<artifactId>javax.annotation-api</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- 数据库连接池 -->
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>

		<!-- mybatis start -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis-spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-generator-core</artifactId>
			<version>1.3.2</version>
		</dependency>
		
		<!-- mysql -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.connector.version}</version>
		</dependency>

		<!-- StringUtils -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.4</version>
		</dependency>

		<!-- jackson -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>${jackson.version}</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.version}</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>${jackson.version}</version>
		</dependency>

		<!-- fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>
		<!-- fastjson -->

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		
		 <!-- redis start -->
	    <dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>${jedis.version}</version>
		 </dependency>
		 <dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>${spring.data.redis.version}</version>
	     </dependency>
	     <!-- redis end -->
	     
	</dependencies>

	<build>
		<finalName>com.maven.web</finalName>
	</build>


</project>
二，添加 Spring-redis.xml  配置文件，内容如下： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

	<!-- blockWhenExhausted: 从Pool中获取Jedis对象，Pool资源耗尽后阻塞maxWaitMillis参数指定时间 -->
	<!-- maxWaitMillis: 从Pool中获取Jedis对象超时时间 -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"
	      p:minIdle="2"
	      p:maxIdle="5"
	      p:maxTotal="8"
	      p:maxWaitMillis="2000"
	      p:testOnBorrow="false"
	      p:testOnReturn="false"
	      p:testWhileIdle="true"
	      p:blockWhenExhausted="true" />

	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
	    <property name="usePool" value="true" />
	    <property name="hostName" value="192.168.230.130" />
	    <property name="port" value="6379" />
	    <property name="password" value="" />
	    <property name="timeout" value="2000" />
		<constructor-arg name="poolConfig" ref="jedisPoolConfig" />
	</bean>
	
	<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
	     <property name="connectionFactory" ref="jedisConnectionFactory" />
	</bean>
</beans>

***********************************

这里需要说明一下：

hostName：填写安装有redis的服务器地址，我这里是安装到本地虚拟机的，如何安装请参看博客：http://www.cnblogs.com/yun965861480/p/6273451.html

port：默认端口是6379

password：自己设置，我这里为空

下面是我启动虚拟机中redis服务的截图，在启动我们项目之前，需要先启动redis：


三，Spring-config.xml 原来的配置中引入redis 的配置文件，如下：

<import resource="classpath:Spring-redis.xml" />

四，redis的使用，我这里直接用的工具类，代码分享如下：

(1) RedisService

package com.maven.web.redis;

import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

/**
 * redis缓存接口。
 *
 * 缓存时间单位默认分钟，
 * 默认timeout值为5，
 * 没有timeout和timeunit的方法默认不设置有效时间，永久有效。
 */
public interface RedisService {

	int EXPIRE_TIME_1 = 1;

	int EXPIRE_TIME_2 = 2;

	int EXPIRE_TIME_5 = 5;

	int EXPIRE_TIME_7 = 7;

	int EXPIRE_TIME_15 = 15;
	
	int EXPIRE_TIME_30 = 30;


	<T> void put(String key, T obj);
	<T> void put(String key, T obj, int timeout);
	<T> void put(String key, T obj, int timeout, TimeUnit unit);

	<T> T get(String key, Class<T> cls);

	<E, T extends Collection<E>> T get(String key, Class<E> cls, Class<T> collectionClass);

	<T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier);
	<T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout);
	<T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout, TimeUnit unit);
	<T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout, TimeUnit unit, boolean refresh);

	<E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier);
	<E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout);
	<E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout, TimeUnit unit);
	<E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout, TimeUnit unit, boolean refresh);

	boolean exists(String key);

	void delete(String key);

	boolean expire(String key, long timeout, TimeUnit timeUnit);
	boolean expire(String key, long timeout);
	
	void put(String key, String value);
	void put(String key, String value, int timeout);
	void put(String key, String value, int timeout, TimeUnit unit);

	String get(String key);
}

(2) RedisServiceImpl

package com.maven.web.redis;

import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.maven.web.util.JsonUtils;

@Component("redisService")
public class RedisServiceImpl implements RedisService {

	private StringRedisTemplate redisTemplate;

	@Autowired
	public void setRedisTemplate(StringRedisTemplate redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	public <T> void put(String key, T obj) {
		redisTemplate.opsForValue().set(key, JsonUtils.toJson(obj));
	}

	public <T> void put(String key, T obj, int timeout) {
		put(key, obj, timeout, TimeUnit.MINUTES);
	}

	public <T> void put(String key, T obj, int timeout, TimeUnit unit) {
		redisTemplate.opsForValue().set(key, JsonUtils.toJson(obj), timeout, unit);
	}
	
	public <T> T get(String key, Class<T> cls) {
		return JsonUtils.fromJson(redisTemplate.opsForValue().get(key), cls);
	}
	
	public <E, T extends Collection<E>> T get(String key, Class<E> cls, Class<T> collectionClass) {
		return JsonUtils.fromJson(redisTemplate.opsForValue().get(key), cls, collectionClass);
	}

	public <T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier) {
		T t = get(key, cls);
		if (t == null) {
			t = supplier.get();
			if (t != null) {
				put(key, t);
			}
		}
		return t;
	}

	public <T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout) {
		T t = get(key, cls);
		if (t == null) {
			t = supplier.get();
			if (t != null) {
				put(key, t, timeout);
			}
		}
		return t;
	}

	public <T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout, TimeUnit unit) {
		T t = get(key, cls);
		if (t == null) {
			t = supplier.get();
			if (t != null) {
				put(key, t, timeout, unit);
			}
		}
		return t;
	}

	public <T> T putIfAbsent(String key, Class<T> cls, Supplier<T> supplier, int timeout, TimeUnit unit, boolean refresh) {
		T t = get(key, cls);
		if (t == null) {
			t = supplier.get();
			if (t != null) {
				put(key, t, timeout, unit);
			}
		} else {
			if (refresh) {
				expire(key, timeout, unit);
			}
		}
		return t;
	}

	public <E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier) {
		T t = get(key, cls, collectionCls);
		if (t == null || t.isEmpty()) {
			t = supplier.get();
			if (t != null && t.size() > 0) {
				put(key, t);
			}
		}
		return t;
	}

	public <E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout) {
		return putIfAbsent(key, cls, collectionCls, supplier, timeout, TimeUnit.SECONDS);
	}

	public <E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout, TimeUnit unit) {
		return putIfAbsent(key, cls, collectionCls, supplier, timeout, unit, false);
	}

	public <E, T extends Collection<E>> T putIfAbsent(String key, Class<E> cls, Class<T> collectionCls, Supplier<T> supplier, int timeout, TimeUnit unit, boolean refresh) {
		T t = get(key, cls, collectionCls);
		if (t == null || t.isEmpty()) {
			t = supplier.get();
			if (t != null && t.size() > 0) {
				put(key, t, timeout, unit);
			}
		} else {
			if (refresh) {
				expire(key, timeout, unit);
			}
		}
		return t;
	}


	public boolean exists(String key) {
		return redisTemplate.hasKey(key);
	}

	public void delete(String key) {
		redisTemplate.delete(key);
	}

	public boolean expire(String key, long timeout, TimeUnit timeUnit) {
		return redisTemplate.expire(key, timeout, timeUnit);
	}
	
	public boolean expire(String key, long timeout) {
		return expire(key, timeout, TimeUnit.MINUTES);
	}
	
	public void put(String key, String value) {
		redisTemplate.opsForValue().set(key, value);
	}

	public void put(String key, String value, int timeout) {
		put(key, value, timeout, TimeUnit.MINUTES);
	}

	public void put(String key, String value, int timeout, TimeUnit unit) {
		redisTemplate.opsForValue().set(key, value, timeout, unit);
	}

	
	public String get(String key) {
		return redisTemplate.opsForValue().get(key);
	}
	
}
(3) JsonUtils 

package com.maven.web.util;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Collection;

import org.apache.commons.lang3.StringUtils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

public final class JsonUtils {

	//public static final Logger LOGGER = LoggerFactory.getLogger(JsonUtils.class);

	private JsonUtils() {}

	private static ObjectMapper objectMapper;

	static {
		objectMapper = new JsonObjectMapper();
		objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
		objectMapper.setDateFormat(new SimpleDateFormat("yyyyMMddHHmmss"));
	}

	public static <T> String toJson(T obj) {
		try {
			return objectMapper.writeValueAsString(obj);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
			//LOGGER.error("class: {} serialize to JSON error: {}", ToStringBuilder.reflectionToString(obj), e);
		}
		return null;
	}

	public static <T> T fromJson(String json, Class<T> cls) {
		try {
			if (StringUtils.isBlank(json)) {
				return null;
			}
			return objectMapper.readValue(json, cls);
		} catch (IOException e) {
			e.printStackTrace();
			//LOGGER.error("deserialize failed! JSON string: {}, class: {}, reason: {}", json, cls, e);
		}
		return null;
	}

	public static <E, T extends Collection<E>> T fromJson(String json, Class<E> cls, Class<T> collectionCls) {
		if (StringUtils.isBlank(json)) {
			return null;
		}
		JavaType javaType = objectMapper.getTypeFactory().constructParametricType(collectionCls, cls);
		try {
			return objectMapper.readValue(json, javaType);
		} catch (IOException e) {
			e.printStackTrace();
			/*LOGGER.error("deserialize failed! JSON string: {}, Object class:{}, Collection class: {}, reason: {}",
					json, cls, collectionCls, e);*/
		}
		return null;
	}
}
(4) JsonObjectMapper 

package com.maven.web.util;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;

public class JsonObjectMapper extends ObjectMapper {
	
	private static final long serialVersionUID = 4769299031472855116L;

	public JsonObjectMapper() {
		// 允许单引号
		this.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
		// 字段和值都加引号
		this.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
		// 数字也加引号
		/*this.configure(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS, true);
		this.configure(JsonGenerator.Feature.QUOTE_NON_NUMERIC_NUMBERS, true);*/
		// 空值处理为空串
		this.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {

			@Override
			public void serialize(
					Object value,
					JsonGenerator jg,
					SerializerProvider sp) throws IOException, JsonProcessingException {
				jg.writeString("");
			}
		});
	}
}

五，准备工作做好了，接下来是测试

(1) 新增RedisController，代码如下：

package com.maven.web.controller;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.maven.web.entity.UserInfo;
import com.maven.web.service.impl.UserService;

@Controller
@RequestMapping("/redis")
public class RedisController {
	
	@Resource
	private UserService userService;
	
	@ResponseBody
	@RequestMapping(value="/userInfo",method=RequestMethod.GET)
	public String getUserInfo(@RequestParam Long uid){
		UserInfo userInfo = userService.getUserInfo(uid);
		if(userInfo!=null){
			return "您要获取的用户名称是："+userInfo.getUserName();
		}
		return "获取用户信息失败";
	}

}
(2) UserService 中添加方法，从缓存中获取用户信息，代码片段如下： 

/** 从缓存中获取 */
	UserInfo getUserInfo(Long uid);
(3) UserServiceImpl 实现，代码片段如下： 

public UserInfo getUserInfo(Long uid) {
		String json = redisService.get(USER_INFO+uid);
		if(json==null){
			UserInfo userInfo = select(uid);
			if(userInfo!=null){
				redisService.put(USER_INFO+uid, userInfo, 1, TimeUnit.HOURS);
			}
			return userInfo;
		}

		return JsonUtils.fromJson(json, UserInfo.class);
	}
六，启动tomcat，测试，我这里用的是google应用，postman

开启debug模式进入后台可以看到，第一次是从数据库查询数据，第二次就是从缓存取数据了：


再看返回结果：



**********************************************************************************************

测试成功，到此集成redis框架就完成了，需要参考项目源码的请点这里：http://pan.baidu.com/s/1kVPrPmZ













小小小爬虫
关注
专栏目录
spring+springMVC+Mybatis+maven框架
02-24
spring+springMVC+Mybatis+maven框架整合，下载好直接可以使用
一个简单的论坛-Spring+SpringMVC+MyBatis+MySQL+Redis
10-25
一个初学者练手项目，开发IDE为IntelliJ IDEA，通过Maven构建，后台采用Spring、SpringMVC、MyBatis，数据库采用MySQL、Redis，前台用到jQuery，图片被上传到七牛云。
Spring+SpringMVC+MyBatis+Maven框架整合
kuandai225的博客
05-05 1485
本文记录了Spring+SpringMVC+MyBatis+Maven框架整合的记录，主要记录以下几点  一、Maven需要引入的jar包  二、Spring与SpringMVC的配置分离  三、Spring与MyBatis的整合  一、Maven需要引入的jar包  本文默认读者已经掌握Maven的使用，Maven配置片段如下  Xml代码      de
Redis 架构详解，值得收藏！
最新发布
架构精进之路
07-31 318
Redis（REmote DIctionary Service）是一个开源的键值对数据库服务器。Redis 更准确的描述是一个数据结构服务器。Redis不是通过迭代或者排序方式处理数据，而是一开始就按照数据结构方式组织。早期，它的使用很像 Memcached，但随着 Redis 的改进，它在许多其他用例中变得可行，包括发布-订阅机制、流（streaming）和队列。主要来说，Redis 是一个内存...
Spring+SpringMVC+Mybatis+Maven
qq_36348637的博客
01-06 297
Maven整合spring整合springMVC整合Mybatis 工具：eclipse javaee IDE 1.先附上maven项目结构图 2.pom.xml文件详细内容 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instanc
Spring+springMVC+Mybatis+Maven项目
10-12
这个项目中包含了数据库sql语句，已经我搭建的时候遇到的问题解决步骤，如果大家有什么问题也可以问我
maven+springmvc+redis+mybatis整合
05-25
本项目以“maven+springmvc+redis+mybatis整合”为主题，旨在提供一个基于这些技术的集成框架，特别强调了利用Redis作为缓存来提升应用性能。下面将详细阐述这个框架中的各个组成部分以及它们之间的协作。 首先，...
基于IDEA+Spring+SpringMVC+Mybatis+Redis+Shiro+Maven实现的教务管理系统+源码
06-23
基于IDEA+Spring+SpringMVC+Mybatis+Redis+Shiro+Maven实现的教务管理系统+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于IDEA+Spring+SpringMVC+...
SSM框架（Spring+SpringMVC+MyBatis）+shiro+Maven.zip
03-14
● 实现方法： 使用MySQL 建立数据库。服务端使用SSM框架（Spring+SpringMVC+MyBatis）+shiro+Maven，使用Myeclipse进行开发。前端使用MUi和HUI框架和vue（与后台交互模板）和Html5+css3来实现移动端App的开发。
framework:SpringMVC + Spring + Mybatis + Redis + Postgresql + Maven +内存缓存
05-06
SpringMVC+Spring+Mybatis+Redis+Postgresql+maven ##概述 经过一段时间架搭建，框架基本成型了。Springmvc+Spring+Mybatis+Redis+Postgresql通过maven进行项目的管理。 之前觉得网上有大量的资料，照猫画虎，搭建...
springmvc+mybatis+maven框架
05-23
框架自己搭建的，可以直接使用，只需要换自己的数据库就可以
spring+springMVC+Mybatis+MYSQL+Redis+Maven项目整合源码
01-06
该项目主要技术架构包括：spring+springMVC+Mybatis+MYSQL+Redis+Maven，适合初学者，简单易懂。
SpringMVC+MyBatis+Maven 完整项目
06-14
开发环境STS，项目完整，只需修改数据库连接配置文件即可，数据库表创建文件已给出。
maven 创建 spring + springmvc + mybatis + redis + mysql 学生查询例子
05-24
用maven创建基于springmvc和mybatis框架的小例子，数据库mysql，用的是redis缓存； jre 1.7，tomcat 7
springMVC+spring+mybatis+redis整合
12-29
springMVC+spring+mybatis+redis整合的maven demo，redis作为二级缓存
Spring+Spring MVC+Mybatis+Maven整合教程(图文详解附代码)
jokeMqc的博客
08-07 341
1.配置整合前所需准备的环境:    这是我搭建的时候用的环境，至于环境的搭建我就不带大家搭建了，百度上一大堆教程 1.1：jdk1.8 1.2：idea2018.1.5 1.3：Maven 3.5.2 2.查看idea中是否安装Maven插件: 2.1：File --&gt; Settings --&gt; Plugins 2.2：如下图所示的步骤进行操作(注:安装完插件，ide...
Idea SpringMVC+Spring+MyBatis+Maven整合
热门推荐
夕下奕林的专栏
07-11 3万+
创建项目 File-New Project 选中左侧的Maven，选中右侧上方的Create from archetype，然后选中下方列表中的webapp，然后点击Next 在GroupId和ArtifactId中填入指定内容，点击Next 直接点Next 输入项目名称，Finish Idea会自动开始下载所依赖的包，等待其完成
SpringMVC+Mybatis+Maven的简单学习
Djs9611的博客
07-24 506
对SpringMVC+Mybatis+Maven的简单理解和其它这是我的第一篇博客，由于最近刚开始实习接触了第一个公司的项目主要是用SpringMVC+Mybatis的框架，然后也是完成了需要开发的内容，所以想写一篇文章来记录自己学习的内容，可能会有很些理解上的偏差，希望能在以后的慢慢学习中逐步提高。（第一次用markdown编辑器，排版不好勉强看看吧......）：springMVC mybati
SSM整合详解：Spring+SpringMVC+MyBatis框架集成教程
"Spring+SpringMVC+MyBatis整合详细教程(SSM)：Spring轻量级框架、SpringMVC作为MVC模式实现、MyBatis持久层框架的整合使用" 在Java开发领域，Spring、SpringMVC和MyBatis组成的SSM框架组合是常见的企业级应用开发...
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值