项目架构01 springMVC+MyBaits+redis+MySQL

最新推荐文章于 2024-04-28 16:39:58 发布
最新推荐文章于 2024-04-28 16:39:58 发布
阅读量386 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： javaee项目架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lwladzhj/article/details/81485733
本文介绍了一个结合Spring MVC、MyBatis、Redis等技术的实战项目，详细展示了如何配置Maven项目，实现数据库与Redis的数据交互及缓存管理。通过具体的代码示例，包括配置文件、实体类、Mapper接口及实现、服务层接口及实现、控制器类等内容，阐述了项目的整体架构和技术要点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

弄了我两天时间，搞起。废话少说，代码就是程序员的语言

<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.lwl</groupId>
	<artifactId>spring_redis</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring_redis Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>4.1.0.RELEASE</spring.version>
		<jackson.version></jackson.version>
	</properties>
	<dependencies>
		<!-- <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-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>
				
		<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
		<dependency>
		    <groupId>org.springframework.data</groupId>
		    <artifactId>spring-data-redis</artifactId>
		    <version>1.5.0.RELEASE</version>
		</dependency>
		
		<!-- <dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>2.0.9.RELEASE</version>
		</dependency> -->
		 
        <!-- https://mvnrepository.com/artifact/org.codehaus.jackson/jackson-mapper-asl -->
		<dependency>
		    <groupId>org.codehaus.jackson</groupId>
		    <artifactId>jackson-mapper-asl</artifactId>
		    <version>1.5.0</version>
		</dependency>
		        
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
		<dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-annotations</artifactId>
		    <version>2.9.0</version>
		</dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
		<dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-core</artifactId>
		    <version>2.9.0</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
		<dependency>
		    <groupId>com.fasterxml.jackson.core</groupId>
		    <artifactId>jackson-databind</artifactId>
		    <version>2.9.0</version>
		</dependency>
		
		<dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.25</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
		<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
		<!-- <dependency>
		    <groupId>com.mchange</groupId>
		    <artifactId>c3p0</artifactId>
		    <version>0.9.5.2</version>
		</dependency> -->
	    <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>0.2.23</version>
        </dependency>

		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.6.2</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-test</artifactId>
		    <version>4.1.0.RELEASE</version>
		    <scope>test</scope>
		</dependency>
		<!-- 	java web 依赖包 -->
		<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        	
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.9</version>
			<scope>test</scope>
		</dependency>

	</dependencies>
	<build>
		<finalName>spring_redis</finalName>
		<plugins>
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>jetty-maven-plugin</artifactId>
				<version>8.1.8.v20121106</version>
				<configuration>
					<webAppConfig>
						<contextPath>/${project.build.finalName}</contextPath>
					</webAppConfig>
				</configuration>
			</plugin>

			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
				<configuration>
					<path>/${project.build.finalName}</path>
				</configuration>

			</plugin>
		</plugins>
	</build>
</project>

 spring-context.xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:cache="http://www.springframework.org/schema/cache"
	xmlns:c="http://www.springframework.org/schema/c"	
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    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  
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-4.0.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
            
 	<!-- class annotation related... start -->
    <context:component-scan base-package="com.lwl.spring_redis" />
 	<context:property-placeholder location="classpath:resources.properties,classpath:redis.properties"/>
 	<!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>
	 -->
	<!-- 数据源 -->
    <!--see https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE_DruidDataSource%E5%8F%82%E8%80%83%E9%85%8D%E7%BD%AE-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!-- 基本属性 url、user、password -->
        <property name="url" value="${connection.url}"/>
        <property name="username" value="${connection.username}"/>
        <property name="password" value="${connection.password}"/>

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${druid.initialSize}"/>
        <property name="minIdle" value="${druid.minIdle}"/>
        <property name="maxActive" value="${druid.maxActive}"/>

        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${druid.maxWait}"/>
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${druid.timeBetweenEvictionRunsMillis}" />

        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${druid.minEvictableIdleTimeMillis}" />

        <property name="validationQuery" value="${druid.validationQuery}" />
        <property name="testWhileIdle" value="${druid.testWhileIdle}" />
        <property name="testOnBorrow" value="${druid.testOnBorrow}" />
        <property name="testOnReturn" value="${druid.testOnReturn}" />

        <!-- 打开PSCache，并且指定每个连接上PSCache的大小  如果用Oracle，则把poolPreparedStatements配置为true，mysql可以配置为false。-->
        <property name="poolPreparedStatements" value="${druid.poolPreparedStatements}" />
        <property name="maxPoolPreparedStatementPerConnectionSize" value="${druid.maxPoolPreparedStatementPerConnectionSize}" />

        <!-- 配置监控统计拦截的filters -->
        <property name="filters" value="${druid.filters}" />

    </bean>
<!-- 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl"
            value="jdbc:mysql://${jdbc.host}:${jdbc.port}/${jdbc.database}?useUnicode=true&amp;characterEncoding=utf8" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="acquireIncrement" value="1" />
        <property name="initialPoolSize" value="5" />
        <property name="maxPoolSize" value="20" />
        <property name="minPoolSize" value="5" />
        <property name="maxStatements" value="100" />
        <property name="testConnectionOnCheckout" value="true" />
    </bean>
 -->
	<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描mapping.xml文件 <property name="mapperLocations" value="classpath:com/ssm/mapper/*.xml"></property> -->
    </bean>
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lwl.spring_redis.vo" />
    </bean>
	<!-- <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean> -->
	<!-- transaction config related... start -->
    <tx:annotation-driven transaction-manager="transactionManager" />
    <bean id="transactionManager"	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- transaction config related... end -->

		
	<!-- 开启缓存注解 -->
  	<cache:annotation-driven />	

	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		p:host-name="${redis.host}" 
		p:port="${redis.port}"
		p:password="${redis.pass}" 
		p:database="${redis.dbIndex}" 
		p:pool-config-ref="poolConfig" />

	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="${redis.maxIdle}" />
		<property name="maxTotal" value="${redis.maxActive}" />
		<property name="maxWaitMillis" value="${redis.maxWait}" />
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
	</bean>
		
	<bean id="stringSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
	
	<!-- 开启事务，可以通过transcational注解控制 -->
	<bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
		<property name="keySerializer" ref="stringSerializer" />
		<property name="enableTransactionSupport" value="true" />
	</bean>
	 
    <!-- 配置RedisCacheManager -->
    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="template" ref="jedisTemplate"/>
        <property name="defaultExpiration" value="${redis.expiration}"/>
    </bean>

    <!-- 配置RedisCacheConfig -->
    <bean id="redisCacheConfig" class="com.lwl.spring_redis.utils.RedisCacheConfig">
        <constructor-arg ref="jedisConnectionFactory"/>
        <constructor-arg ref="jedisTemplate"/>
        <constructor-arg ref="cacheManager"/>
    </bean>
</beans>

spring-mvc.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"    
    xmlns:context="http://www.springframework.org/schema/context"    
    xmlns:mvc="http://www.springframework.org/schema/mvc"    
    xsi:schemaLocation="http://www.springframework.org/schema/beans      
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd      
                        http://www.springframework.org/schema/context      
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd      
                        http://www.springframework.org/schema/mvc      
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">    
    <!-- class annotation related... start 
   		 	<context:component-scan base-package="com.ssm.controller" />
     	class annotation related... end 
     -->
     <!-- 添加注解驱动  使用注解标注的类生效-->      
    <mvc:annotation-driven />
    <!-- 设置能访问静态资源 -->    
    <mvc:default-servlet-handler/>
    <!--扫描controller-->
    <context:component-scan base-package="com.lwl.spring_redis.controller" />    

    <!-- jsp page related... start -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <!-- jsp page related... end -->

    <!-- rest json related... start -->
    <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>application/json;charset=UTF-8</value>
            </list>
        </property>
    </bean>

    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter" />
            </list>
        </property>
    </bean>
    <!-- rest json related... end -->
</beans>

jdbc.properties配置：

#dataSource configure
connection.url=jdbc:mysql://localhost:3306/user?useUnicode=true&amp;characterEncoding=utf8
connection.username=root
connection.password=
 
druid.initialSize=10
druid.minIdle=10
druid.maxActive=50
druid.maxWait=60000
druid.timeBetweenEvictionRunsMillis=60000
druid.minEvictableIdleTimeMillis=300000
druid.validationQuery=SELECT 'x'
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
druid.poolPreparedStatements=true
druid.maxPoolPreparedStatementPerConnectionSize=20
druid.filters=wall,stat

log4j.properties配置：

# Global logging configuration
log4j.rootLogger=WARN,stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c:%L - %m%n
# mybatis log
log4j.logger.com.ssm.dao.UserMapper=DEBUG
# lyz log
log4j.logger.com.ssm.controller=DEBUG
log4j.logger.com.ssm.service=DEBUG

redis.properties配置：

#redis 服务器地址
redis.host=127.0.0.1
#redis 端口号
redis.port=6379
#redis 登录密码
redis.pass=password 
#reids 的数据库号
redis.dbIndex=0  
redis.expiration=3000  
redis.maxIdle=300  
redis.maxActive=600  
redis.maxWait=1000  
redis.testOnBorrow=true

web.xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  	  	 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    	 version="3.1">
  
  	<display-name>Archetype Created Web Application</display-name>
  	<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:application.xml</param-value>
    </context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <!-- 编码过滤器 -->
    <filter>
        <filter-name>springfilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>springfilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
     <!-- Spring MVC servlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

RedisCacheConfig.java：

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
     protected final static Logger log = LoggerFactory.getLogger(RedisCacheConfig.class);

        private volatile JedisConnectionFactory mJedisConnectionFactory;
        private volatile RedisTemplate<String, String> mRedisTemplate;
        private volatile RedisCacheManager mRedisCacheManager;

        public RedisCacheConfig() {
            super();
        }

        public RedisCacheConfig(JedisConnectionFactory mJedisConnectionFactory, RedisTemplate<String, String> mRedisTemplate, RedisCacheManager mRedisCacheManager) {
            super();
            this.mJedisConnectionFactory = mJedisConnectionFactory;
            this.mRedisTemplate = mRedisTemplate;
            this.mRedisCacheManager = mRedisCacheManager;
        }

        public JedisConnectionFactory redisConnectionFactory() {
            return mJedisConnectionFactory;
        }

        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
            return mRedisTemplate;
        }

        public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
            return mRedisCacheManager;
        }
        
        @Bean
        public KeyGenerator keyGenerator() {
            
        	return new KeyGenerator() {//匿名内部类
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    //规定  本类名+方法名+参数名 为key
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName()+"_");
                    sb.append(method.getName()+"_");
                    for (Object obj : params) {
                        sb.append(obj.toString()+",");
                    }
                    return sb.toString();
                }
            };
        }
}

User.java:

​
public class User implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = -5244288298702801619L;
    private int id;
    private String userName;
    

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
 
    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + "]";
    }
}

​

UserMapper.java:

package com.lwl.spring_redis.mapper;

import java.util.List;

import com.lwl.spring_redis.vo.User;

public interface UserMapper {

    public User selectByPrimaryKey(int userId);

    public List<User> selectAllUser();
 
}

UserMapper.xml:

​
<?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.lwl.spring_redis.vo.UserMapper" >
    <resultMap id="BaseResultMap" type="com.lwl.spring_redis.vo.User">
        <id column="id" property="id" jdbcType="INTEGER" />
        <result column="userName" property="userName" jdbcType="VARCHAR" /> 
    </resultMap>
    <sql id="Base_Column_List">
        id,userName 
    </sql>
    
    <!-- 查询所有的user -->
    <select id="selectAllUser" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from user
    </select>
 
 
</mapper>

​

UserService.java:

public interface IUserService {

     public List<User> getAllUser();
     
}

UserServiceImpl.java:

​
@Service  
public class UserServiceImpl implements IUserService {

    @Resource
    private UserMapper userDao;
  
    @Cacheable("getAllUser")
    @Override
    public List<User> getAllUser() {
        return this.userDao.selectAllUser();
    }
 
}

​

UserController.java:

@Controller
@RequestMapping("/user")
public class UserController {

    @Resource
    private IUserService userService;

    /**
     * 查询所有User
     * 
     * @param request
     * @param model
     * @return
     */
    @RequestMapping(value = "/showList", method = RequestMethod.GET)
    public String showUsers(Model model) { 
        List<User> userList = new ArrayList<User>();
        userList = userService.getAllUser();
        model.addAttribute("userList", userList); // 填充数据到model
        return "showUser";
    }
}

showUser.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" isELIgnored="false" %>
    
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
	${userList}
</body>
</html>

 

启动tomcat7:run,访问链接 /projectName/user/showUser,显示如下：

 

 查看redis服务器keys:

 查看值：

 完成架构。

当停掉mysql 服务时，net stop mysql。访问网页仍然能显示查询数据。

LAMP架构之redis（3）：redis+mysql架构
weixin_43803940的博客
02-07 1749
一、redis结合mysql （1）流程图 用户端访问时，请求直接发送给redis，假如redis有数据就可以直接返给用户，假如redis没有，他就会调取数据库上的数据，用户写入的时候是直接写到了数据库上 （2）实验环境 本次实验一共需要三个节点，在这里选取server2，server3和server4，其中server2作为redis节点，必须是master； server3是作为lamp架构，在这里一定要注意选取一个干净的server节点去重...
SpringMVC+Spring+mybatis+Redis项目从零开始--分布式项目结构搭建
if(true){ I love it }
01-18 2万+
Springmvcspring mybatis maven mysql redis项目从零开始 一. SSM项目-目录框架搭建实现 1. 序言 做SSM项目有一段时间，从来没有系统性的对整个项目结构做一次总结，临近年关，趁着有时间，想把整个SSM项目框架的相关内容梳理一下，同时也弥补自己不足，可能有些考题考虑不周，请大家多多谅解。 本系列文章，会涉及到Springmvc,spring,mybatis,maven ,mysql,redis等框架知识，如果自身对相关知识不了解的同学，请到对应
springmvc+redis+mysql（数据库连接简单实现）数据缓存
08-09
实现redis与springmvc配置，数据库连接简单实现，待完善实现连接池
SpringMVC + MyBatis + Mysql + Redis(作为二级缓存) 配置
热门推荐
xiadi934的专栏
03-03 4万+
项目环境： 在SpringMVC + MyBatis + Mysql。Redis部署在Linux虚拟机。1、整体思路 参考Ehcache实现MyBatis二级缓存代码（Maven引用对应jar查阅） 使用Spring管理Redis连接池 模仿EhcacheCache，实现RedisCache 2、pom.xml中加入Maven依赖<!-- spring-redis实现 --> <dependency
redis springmvc mysql_redis和mysql怎么一起在springmvc里面
weixin_35951275的博客
02-03 231
展开全部一、mysql集成到springMVC中的方法：1、在SRC目录下创建一个32313133353236313431303231363533e4b893e5b19e31333361323538db-config.properties文件来存放我们的数据源配置信息：db.url= jdbc:mysql:///springmvcdb?useUnicode=true&characterEn...
mysql redis缓存配置_SpringMVC + MyBatis + Mysql + Redis(作为二级缓存) 配置
weixin_42168750的博客
02-01 160
项目环境： 在SpringMVC + MyBatis + MySQL。Redis部署在Linux虚拟机。1、整体思路参考Ehcache实现MyBatis二级缓存代码(Maven引用对应jar查阅)使用Spring管理Redis连接池模仿EhcacheCache，实现RedisCache2、pom.xml中加入Maven依赖1 2 3 org.springframework.data4 ...
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码...
基于javaweb+ssm+redis+elk+layui+jsp的全栈学习的博客项目源码+数据库+说明.zip
01-13
使用ssm（spring+springmvc+mybaits）+redis+elk作为后台技术，使用layui+jsp+ajax作为前端技术 ### 技术亮点： 1.注册登录时利用ajax对不合适的输入做出提示，并使用MD5+salt对密码进行加密; 2.使用elk替换了...
Java项目:无人智慧超市管理系统(java+SpringBoot+Mybaits+Vue+elementui+mysql)
最新发布
m0_66863468的博客
04-28 384
项目介绍 基于Springboot+vue实现的无人智慧超市管理系统 本项目分为前后台，分为用户和管理员两个角色 用户：登录、注册、商品信息（在商品信息列表页面的输入栏中输入商品名称、商品分类和价格进行查询，可以查看到商品信息详细，并根据需要对商品信息详情信息进行添加到购物车、立即购买、收藏、赞一下、踩一下或评论）、个人中心、我的订单、我的收藏等功能 管理员：登录、个人中心、用户管理、商品分类管理、商品信息管理、仓储信息管理、系统管理、订单管理等功能 环境需要 1.运行环境：最好是java jd
适合java web全栈学习的博客项目（ssm+redis+elk+layui+jsp）
02-11
使用ssm（spring+springmvc+mybaits）+redis+elk作为后台技术，使用layui+jsp+ajax作为前端技术 ### 技术亮点： 1.注册登录时利用ajax对不合适的输入做出提示，并使用MD5+salt对密码进行加密; 2.使用elk替换了...
spring+springMVC+Mybatis+MYSQL+Redis+Maven项目整合源码
01-06
该项目主要技术架构包括：spring+springMVC+Mybatis+MYSQL+Redis+Maven，适合初学者，简单易懂。
SSM+redis+mysql框架实现的一个简单博客
03-31
SSM+redis+mysql框架实现的一个简单博客，SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客
基于Redis和mysql架构，如果保证数据一致性
小草的博客
12-21 1373
如图所示，是redis+mysql整体架构设计该设计会出现一个问题，如下图所示我们在面试的时候，面试官还可能会问各种没有场景化的纯粹的技术问题，比如说： “你这个最终一致性方案”还是会存在数据不一致的问题啊？那怎么解决？先不用慌，技术是为业务服务的，所以不同的业务场景，对于技术的选择和方案的 设计都是不同的，所以这个时候，可以反问面试官，具体的业务场景是什么？大家一定要记住，某个技术方案不可能适用于所有的业务场景，只有最合适的方案， 没有最优的方案。
redis mysql完美结合_高并发架构系列：Redis缓存和MySQL数据一致性方案详解
weixin_32719533的博客
01-19 3635
需求起因在高并发的业务场景下，数据库大多数情况都是用户并发访问最薄弱的环节。所以，就需要使用redis做一个缓冲操作，让请求先访问到redis，而不是直接访问MySQL等数据库。这个业务场景，主要是解决读数据从Redis缓存，一般都是按照下图的流程来进行业务操作。读取缓存步骤一般没有什么问题，但是一旦涉及到数据更新：数据库和缓存更新，就容易出现缓存(Redis)和数据库(MySQL)间的数据一致性...
分享一个ES+Redis+MySQL的高可用架构设计
架构文摘
05-16 283
目录背景ES 高可用方案会员 Redis 缓存方案高可用会员主库方案异常会员关系治理展望：更精细化的流控和降级策略‍背景会员系统是一种基础系统，跟公司所有业务线的下单主流程密切相关。如果会员系统出故障，会导致用户无法下单，影响范围是全公司所有业务线。所以，会员系统必须保证高性能、高可用，提供稳定、高效的基础服务。随着同程和艺龙两家公司的合并，越来越多的系统需要打通同程 APP、艺龙 APP、同程微...
php redis mysql 架构_数据库高可用架构(MySQL、Oracle、MongoDB、Redis)
weixin_36328628的博客
01-28 302
一、MySQL MySQL小型高可用架构 方案：MySQL双主、主从 + Keepalived主从自动切换 服务器资源：两台PC Server 优点：架构简单，节省资源 缺点：无法线性扩展，主从失败之后需要手动恢复主从架构 MySQL中型高可用架构 方案：MMM + MySQL双主 + 多从高可用方案一、MySQLMySQL小型高可用架构方案：MySQL双主、主从 + Keepalived主从自动...
springmvc + mybatis + ehcache + redis 分布式架构
01-08 170
框架简介--主要定位于互联网企业架构，已内置企业信息化系统的基础功能和高效的代码生成工具，包括：系统权限组件、数据权限组件、数据字典组件、核心工具 组件、视图操作组件、工作流组件组件、代码生成等。采用分层设计、双重验证、提交数据安全编码、密码加密、访问验证、数据权限验证。平台简介 是一个分布...
redis springmvc mysql_SpringMVC+Mybatis+MySQL配置Redis缓存
weixin_32620249的博客
02-11 124
SpringMVC+Mybatis+MySQL配置Redis缓存1.准备环境:SpringMVC：spring-framework-4.3.5.RELEASE-distMybatis：3.4.2MySQL：5.0JDK：1.8IDE：Eclipse4.6.1以及配置好的SpringMVC+Mybatis项目2.需要添加的jar包jedis-2.9.0.jar或者使用POM配置redis.clien...
springmvc+链接mysql_SpringMVC 连接Redis数据库
weixin_39525307的博客
02-11 117
1、pom.xmlredis.clientsjediscompile2、测试类/****/package cn.bizbook.resource.manage.dao.impl;import static org.junit.Assert.*;import org.junit.Test;import redis.clients.jedis.Jedis;/*** @author jiangxingq...
SSM框架集成教程：快速构建Spring+SpringMVC+Mybaits应用
标题中提到的技术栈“Spring+springMVC+mybaits+layui+bootstrap+mysql+oracle”，是一组广泛用于Java企业级开发的开源框架和技术。下面详细说明每个技术组件的知识点： 1. **Spring Framework（Spring）** - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值