spring-springmvc-mybatis-dubbo-redis-mysql实现soa搭建,数据查询,数据缓存

最新推荐文章于 2024-06-24 07:52:34 发布

wb54979

最新推荐文章于 2024-06-24 07:52:34 发布

阅读量3.5k

点赞数 1

分类专栏： java 文章标签： dubbo redis

本文链接：https://blog.csdn.net/wangbo54979/article/details/77773110

版权

java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

1:首先介绍windows下安装redis: redis这部分采取 http://blog.csdn.net/jquerys/article/details/48624949博主的博文我看他上面写的挺好就不自觉写了直接截图重要部分来说

1、Redis简介
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hashs（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

2、windows下安装redis
下载地址https://github.com/dmajkic/redis/downloads。下载到的Redis支持32bit和64bit。根据自己实际情况选择，我选择32bit。把32bit文件内容拷贝到需要安装的目录下,比如：D:\dev\redis-2.4.5。

打开一个cmd窗口，使用cd命令切换到指定目录（D:\dev\redis-2.4.5）运行 redis-server.exe redis.conf 。运行以后出现如下界面。

这就说明Redis服务端已经安装成功。

重新打开一个cmd窗口，使用cd命令切换到指定目录（D:\dev\redis-2.4.5）运行 redis-cli.exe -h 127.0.0.1 -p 6379，其中 127.0.0.1是本地ip，6379是redis服务端的默认端口。运行成功如下图所示。
这样，Redis windows环境下搭建已经完成，是不是很简单。

这样，Redis windows环境下搭建已经完成，是不是很简单。

环境已经搭建好，总得测试下吧。比如：存储一个key为test，value为hello word的字符串，然后获取key值。

正确输出 hell word，测试成功！

2:dubbo windows下的安装简介:

1：下载zookeeper ，稳定版3.4.8，最新版3.5.1，解压后，进入到conf目录，复制一份zoo_sample.conf，改名为zoo.conf，用无格式编辑器（比如sublime text，notepad等）打开，修改dataDir=/tmp/zookeeper为你的动物园管理员数据存放路径，比如笔者的为D：/软件/ zookeeperData /动物园管理员，修改为dataDir=D:/software/zookeeperData/zookeeper，保存即可，如果要配置ZK集群，还需要其他配置，暂时不说集群这一块，后面涉及到了再说。

zookeeper国内下载镜像地址：http ://mirrors.hust.edu.cn/apache/zookeeper/ bin /找到启动服务点击运行成功之后

2：下载JDK，maven安装配置这基础的东西就不说了找文档看看就会

3：dubbo-admin.war

这个战争包是阿里达博团队开发的一个可视化操作达博的后台管理服务，可是查看机器，提供者，消费者，以及手动配置负载权重等。将次包下载后，放在tomcat的的的webapps目录下，如果你的tomcat的和动物园管理员不是同一台服务器，需要修改战争包下的配置文件，将地址指向的动物园管理员的服务地址，端口是动物园管理员的端口，默认2181。

如果对于只是想搭建完了测试看下效果上面zookeeper 安装步骤下载安装运行就行 dubbo-admin.war 那就不是重点了

环境方面就说到这里了下面直接截代码了至于项目的创建步骤我就不一一截图了因为我的博文中有发过一篇一步步怎么创建的

项目整体架构如下: 名字可能起的有点另类

下面一一看一下子项目的结构图:

先是action: dubbo文件标错不要管不影响使用

然后是api:

然后是api-imp 实现:

然后是api-core 核心工具类都放他里面包括所有的 maven jar包仓库

然后是api-pojo 所有的实体类都放这里:

到这里项目的基本结构就这样了，下面开始先讲如何搭建dubbo 并且测试:

这里是 api-core 里面包含的所有jar仓库：

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
	xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>cn.dubbo</groupId>
		<artifactId>soa-dubbo</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<groupId>cn.dubbo.core</groupId>
	<artifactId>dubbo-core</artifactId>
	<name>dubbo-core</name>
	<url>http://maven.apache.org</url>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>4.1.4.RELEASE</spring.version>
		<spring-ck.version>3.0.5.RELEASE</spring-ck.version>
		<jackson.version>2.5.0</jackson.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.0</version>
		</dependency>

		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>



		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring-ck.version}</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<version>2.5.3</version>
			<exclusions>
				<exclusion>
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.4.6</version>
		</dependency>

		<dependency>
			<groupId>com.netflix.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>1.1.10</version>
		</dependency>

		<dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.6</version>
		</dependency>


		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

		<!-- mybatis 包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
		</dependency>

		<!--mybatis spring 插件 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.2</version>
		</dependency>

		<!-- mysql连接 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.34</version>
		</dependency>

		<!-- 数据源 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.12</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.4</version>
		</dependency>

		<!-- json -->
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.9.13</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.3</version>
		</dependency>

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

		<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>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.4</version>
		</dependency>

		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.2.2</version>
		</dependency>

		<!-- servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.0.1</version>
		</dependency>

		<dependency>
			<groupId>com.jfinal</groupId>
			<artifactId>jfinal-weixin</artifactId>
			<version>1.7</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.4.0.RELEASE</version>
		</dependency>

		<!-- spring-data-redis redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.6.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.8.0</version>
		</dependency>

	</dependencies>
</project>

然后是dubbo-api 第一个接口:

import org.dubbo.pojo.User;

public interface UserService {
	User findById(int id);
}

然后是dubbo-api-imp 实现:

@Service("userService")
public class UserServiceImp implements UserService {

	@Resource
	UserMapper userMapper;

	public User findById(int id) {
		User us = userMapper.findById(1);
		return us;
	}

}

然后是UserMapper:

public interface UserMapper {
	User findById(int id);
}

然后是 UserMapper.xml 写sql语句的下面那个支持缓存配置你先别管，，它是跟redis结合用的

<?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="org.dubbo.api.dao.UserMapper">
	<!-- 支持缓存配置 -->
	<cache eviction="LRU" type="org.dubbo.api.redis.RedisCache" />
	<resultMap id="user" type="org.dubbo.pojo.User">
		<id column="userid" property="userid" />
		<result column="name" property="name" />
	</resultMap>

	<select id="findById" parameterType="int" resultType="user">
		select * from user where userid =
		#{id}
	</select>
</mapper>

然后是一个dubbo的运行类里面就一个main方法:

public class DubboMain {

	static ClassPathXmlApplicationContext context;

	public static void main(String[] args) throws IOException {
		context = new ClassPathXmlApplicationContext(
				new String[] { "dubbo.xml" });
		context.start();
		System.in.read(); // 按任意键退出
	}

}

下面出来的基本都是配置文件了:

db.properties 数据库资源文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/wb??useUnicode=true&characterEncoding=UTF-8
username=root
password=1234
c3p0.pool.size.max=20
c3p0.pool.size.min=5
c3p0.pool.size.ini=3
c3p0.pool.size.increment=2

dubbo.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:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans       
    http://www.springframework.org/schema/beans/spring-beans.xsd       
    http://code.alibabatech.com/schema/dubbo        
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	<!-- 提供方应用信息，用于计算依赖关系 -->
	<dubbo:application name="dubbo_provider" />

	<!-- 使用zookeeper注册中心暴露服务地址 -->
	<dubbo:registry address="127.0.0.1:2181" protocol="zookeeper" />

	<!-- 用dubbo协议在20880端口暴露服务 -->
	<dubbo:protocol name="dubbo" port="20880" />
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:service interface="org.dubbo.api.service.UserService" ref="userService"/>
	<bean id="userService" class="org.dubbo.api.imp.UserServiceImp"></bean>
	<import resource="classpath*:applicationMybatis.xml" />
</beans>

log4f.properties

### set log levels ###  
log4j.rootLogger = INFO , C , D , E   
  
### console ###  
log4j.appender.C = org.apache.log4j.ConsoleAppender  
log4j.appender.C.Target = System.out  
log4j.appender.C.layout = org.apache.log4j.PatternLayout  
log4j.appender.C.layout.ConversionPattern = [%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n  
  
### log file ###  
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.D.File = ../logs/ServerManager-Info.log  
log4j.appender.D.Append = true  
log4j.appender.D.Threshold = INFO   
log4j.appender.D.layout = org.apache.log4j.PatternLayout  
log4j.appender.D.layout.ConversionPattern = [%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n  
  
### exception ###  
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.E.File = ../logs/ServerManager-Error.log  
log4j.appender.E.Append = true  
log4j.appender.E.Threshold = ERROR   
log4j.appender.E.layout = org.apache.log4j.PatternLayout  
log4j.appender.E.layout.ConversionPattern = [%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n  

log4j.logger.com.strive.cms=DEBUG

mybatis-config.xml; 里面的配置先别管 redis 缓存的时候会用到

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

	<settings>

		<!-- 全局映射器启用缓存 *主要将此属性设置完成即可 -->
		<setting name="cacheEnabled" value="true" />

		<!-- 查询时，关闭关联对象即时加载以提高性能 -->
		<setting name="lazyLoadingEnabled" value="false" />

		<!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
		<setting name="multipleResultSetsEnabled" value="true" />

		<!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
		<setting name="aggressiveLazyLoading" value="true" />

	</settings>

</configuration>

applicationMybatis.xml 文件中上面三个bean 涉及到 redis 可以先不管，只要api-core里面包导的没错不会报错的你也可以先删除了

<?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:lang="http://www.springframework.org/schema/lang" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:cache="http://www.springframework.org/schema/cache"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang 
        http://www.springframework.org/schema/lang/spring-lang.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache.xsd">

	<!-- 加载配置文件 这里就一次性 把数据库和redis的文件都加载了 -->
	<context:property-placeholder location="classpath*:db.properties,redis.properties" />


	<!-- redis数据源 -->
	<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>

	<!-- spring-data-数据工厂 -->
	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="password" value="${redis.pass}" />
		<property name="usePool" value="true" />
		<property name="hostName" value="${redis.host}" />
		<property name="port" value="${redis.port}" />
		<property name="poolConfig" ref="poolConfig" />
	</bean>


	<!-- 使用中间类解决RedisCache.jedisConnectionFactory的静态注入，从而使MyBatis实现第三方缓存 -->
	<bean id="redisCacheTransfer" class="org.dubbo.api.redis.RedisCacheTransfer">
		<property name="jedisConnectionFactory" ref="jedisConnectionFactory" />
	</bean>




	<!-- 数据源 ,使用dbcp -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
	</bean>

	<!-- sqlSessionFactory -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 加載mybatis的配置文件 -->
		<property name="configLocation" value="classpath:mybatis-config.xml" />
		<property name="typeAliasesPackage" value="org.dubbo.pojo"></property>
		<property name="mapperLocations" value="classpath:org/dubbo/api/dao/*.xml" />
		<!-- 数据源 -->
		<property name="dataSource" ref="dataSource" />
	</bean>


	<!-- mapper批量扫描，从mapper包中扫描出mapper接口，自动创建代理对象并且在spring容器中注册 -->
	<!-- 自动扫描出来的mapper的bean的id为mapper类名（首字母小写） -->
	<!-- 扫描多个包用,分开 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="org.dubbo.api.dao" />
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
	</bean>

	<!-- 事物管理器 对mybatis操作数据库事物控制，spring使用Jdbc的事物控制类 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 数据源 dataSource在applicationContext-dao.xml中配置了 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- aop -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice" pointcut="execution(* org.dubbo.api.imp..*.*(..))" />
	</aop:config>


</beans>

redis.properties 我这里就一次性先贴出来了免得等下又贴配置文件

redis.host=127.0.0.1
redis.port=6379  
redis.pass=
redis.maxIdle=300  
redis.maxActive=600  
redis.maxWait=1000  
redis.testOnBorrow=true

好了这样dubbo就差不多了只是运行一下看效果不跟mybatis打交道的话

根据上面所说的配置好

zookeeper 然后找到启动文件zkServer.cmd 点击运行会出现：

出现了这个继续运行找到dubbo-api-imp 实现里面的哪个DubboMain 点击运行main 如果不报错你会看到以下图如果报错说明你api-core里面导的包有问题:

这边没报错，好的离成功又近了一步回去看 zookeeper 运行的命令窗口会看到:

如果这上面打印了你在项目中写的接口证明你又离成功又近了一步了，然后我们继续往下整，整mybatis数据库查询数据:

下面开始截 dubbo-action 里面的配置以及代码:

action 如下:

@Controller
@Scope("prototype")
@RequestMapping(value = "/wx")
public class UserAction {

	@Autowired
	public UserService userService;


	@RequestMapping(value = "/listUsers", method = RequestMethod.GET)
	public ModelAndView listUsers(HttpServletRequest request) {
		ModelAndView andView = new ModelAndView();
		User u = userService.findById(1);
		andView.addObject("A",u);
		andView.setViewName("index");
		return andView;
	}
}

然后是配置文件以及jsp :

首先是web.xml: 一个web程序的入口就是web.xml 这里就简单的配置了一下

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	<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*:springmvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

	<filter>
		<filter-name>SpringEncodingFilter</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>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>SpringEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<!-- log4j配置，文件路径，因为是跟随项目启动 -->
	<context-param>
		<param-name>log4jConfigLocation</param-name>
		<param-value>classpath:log4f.xml</param-value>
	</context-param>
	<!-- 配置log4j.xml变量，如果需要动态的就使用下面方式，使用方法${name} -->
	<context-param>
		<param-name>controller</param-name>
		<param-value>controller-log</param-value>
	</context-param>

	<context-param>
		<param-name>loggingLevel</param-name>
		<param-value>info</param-value>
	</context-param>
	<!-- 加载log4j配置文件 -->
	<listener>
		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
	</listener>
	<welcome-file-list>
		<welcome-file>login.jsp</welcome-file>
	</welcome-file-list>
</web-app>

然后是dubbo-action.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:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	           http://www.springframework.org/schema/beans/spring-beans.xsd
	                   http://code.alibabatech.com/schema/dubbo
	                           http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

	<!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->
	<!--<dubbo:application name="consumer-of-helloworld-app"/> -->

	<!-- 使用multicast广播注册中心暴露发现服务地址 -->
	<!--<dubbo:registry address="multicast://224.5.6.7:1234"/> -->

	<!-- 公共信息，也可以用dubbo.properties配置 -->
	<dubbo:application name="annotation-consumer" />
	<dubbo:registry address="127.0.0.1:2181" protocol="zookeeper" />
	<!-- 扫描注解包路径，多个包用逗号分隔，不填pacakge表示扫描当前ApplicationContext中所有的类 -->
	<!--<dubbo:annotation package="com.alibaba.dubbo.demo"/> -->

	<!-- 生成远程服务代理，可以和本地bean一样使用demoService -->
	<dubbo:reference id="userService" interface="org.dubbo.api.service.UserService"/>

	<!-- 声明需要引用的服务接口 -->

</beans>

log4j.xml:

<?xml version="1.0" encoding="UTF-8"?>    
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
	<!-- \u53ef\u4ee5\u914d\u7f6e\u591a\u4e2aappender\u6765\u5bf9\u5e94\u4e0d\u540c\u7684\u8f93\u51fa\uff0c\u5982\u6587\u4ef6\u8f93\u51fa\uff0csql\u8f93\u51fa\uff0c\u63a7\u5236\u53f0\u8f93\u51fa\uff0c\u90ae\u4ef6\u8f93\u51fa\u7b49 -->
	<!-- [\u63a7\u5236\u53f0STDOUT] \u4e0d\u540c\u7684\u8f93\u51fa\u7c7b\u578b\u5bf9\u5e94\u7740\u4e0d\u540c\u7684calss\uff0c\u5982\u63a7\u5236\u53f0\u8f93\u51faclass\u5bf9\u5e94\u7740 
		org.apache.log4j.ConsoleAppender -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">  <!-- name\u63d0\u4f9b\u7ed9logger\u6216\u8005root\u8c03\u7528 -->
		<param name="encoding" value="GBK" />  <!-- \u4fdd\u5b58\u5b57\u7b26\u96c6 -->
		<param name="target" value="System.out" />  <!-- \u8f93\u51fa\u5230\u63a7\u5236\u53f0 -->
		<layout class="org.apache.log4j.PatternLayout"> <!-- loyout\u8868\u793a\u8f93\u51fa\u65b9\u5f0f\uff0c\u53ef\u4ee5\u591a\u79cd\uff0cclass\u503c\u533a\u5206\uff0cPatternLayout\u8868\u793a\u81ea\u5b9a\u4e49\u683c\u5f0f -->
			<param name="ConversionPattern"
				value="%d{ISO8601} \u8017\u65f6\uff1a%r [\u65e5\u5fd7\u6765\u81ea\uff1a%-40.40c{3} \u65e5\u5fd7\u7c7b\u578b: %-5p \u65e5\u5fd7\u5185\u5bb9\uff1a%m]%n" />  <!-- \u8f93\u51fa\u683c\u5f0f\uff0c\u540e\u9762\u89e3\u91ca -->
		</layout>
		<!--filter\u8fc7\u6ee4\u5668\u8bbe\u7f6e\u8f93\u51fa\u7684\u7ea7\u522b:ALL < DEBUG < INFO < WARN < 
			ERROR < FATAL < OFF \u6240\u6709\u4e0b\u9762\u8f93\u51fa\u7684\u662fdebug\u5230warn\u4e0d\u4f1a\u6709error\u548cfatal -->
		<filter class="org.apache.log4j.varia.LevelRangeFilter">
			<param name="levelMin" value="debug" />
			<param name="levelMax" value="warn" />
			<param name="AcceptOnMatch" value="true" />  <!-- \u7b54\u6848\uff1ahttp://bbs.csdn.net/topics/350195913 -->
		</filter>
	</appender>

	<!-- [\u516c\u5171Appender] \u8fd9\u4e2aclass\u8868\u793a\u8f93\u5165\u5230\u6587\u4ef6\uff0c\u5e76\u4e14\u6309\u65e5\u671f\u751f\u6210\u65b0\u6587\u4ef6 -->
	<appender name="DEFAULT-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="File" value="${webapp.root}/logs/common-default.log" />  <!-- ${webapp.root}\u9879\u76ee\u6839\u8def\u5f84\uff0c\u81ea\u52a8\u83b7\u5f97\uff0c\u4e0d\u7528\u914d\u7f6e\uff0c\u53ef\u81ea\u5df1\u5728web.xml\u4e2d\u914d\u7f6e -->
		<param name="Append" value="true" />  <!-- \u662f\u5426\u9879\u76ee\u91cd\u542f\u7ee7\u7eed\u4fdd\u5b58\u4e4b\u524d\u65e5\u5fd7 -->
		<param name="encoding" value="GBK" />
		<param name="threshold" value="all" /> <!-- \u8bb0\u5f55\u6240\u6709\u7c7b\u578b\u65e5\u5fd7\uff0c\u8bb0\u5f55\u5b83\u548c\u6bd4\u5b83\u7b49\u7ea7\u9ad8\u7684\u65e5\u5fd7all<debug -->
		<param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />  <!-- \u65e5\u671f\u683c\u5f0f \u4f8b\u5b50\uff1acommon-default.log.2015-09-17.log -->
		<layout class="org.apache.log4j.PatternLayout">  <!-- \u8f93\u51fa\u65b9\u5f0f -->
			<param name="ConversionPattern"
				value="%d{ISO8601} \u8017\u65f6\uff1a%r [\u65e5\u5fd7\u6765\u81ea\uff1a%-40.40c{3} \u65e5\u5fd7\u7c7b\u578b: %-5p \u65e5\u5fd7\u5185\u5bb9\uff1a%m]%n" />
		</layout>
	</appender>

	<!-- [debug\u65e5\u5fd7APPENDER] -->
	<appender name="DEBUG-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="File" value="${webapp.root}/logs/controller/debug-log.log" />
		<param name="Append" value="true" />
		<param name="encoding" value="GBK" />
		<param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern"
				value="%d{ISO8601} \u8017\u65f6\uff1a%r [\u65e5\u5fd7\u6765\u81ea\uff1a%-40.40c{3} \u65e5\u5fd7\u7c7b\u578b: %-5p \u65e5\u5fd7\u5185\u5bb9\uff1a%m]%n" />
		</layout>
	</appender>

	<!-- [info\u65e5\u5fd7APPENDER] -->
	<appender name="INFO-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="File" value="${webapp.root}/logs/controller/info-log.log" />
		<param name="Append" value="false" />
		<param name="encoding" value="GBK" />
		<param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern"
				value="%d{ISO8601} \u8017\u65f6\uff1a%r [\u65e5\u5fd7\u6765\u81ea\uff1a%-40.40c{3} \u65e5\u5fd7\u7c7b\u578b: %-5p \u65e5\u5fd7\u5185\u5bb9\uff1a%m]%n" />
		</layout>
		<!-- \u6211\u53ea\u60f3\u8bb0\u5f55info\u65e5\u5fd7\uff0c\u5c31\u505a\u5982\u4e0b\u8bbe\u7f6e -->
		<filter class="org.apache.log4j.varia.LevelRangeFilter">
			<param name="LevelMax" value="info" />
			<param name="LevelMin" value="info" />
		</filter>
	</appender>

	<!-- [\u7ec4\u4ef6\u65e5\u5fd7APPENDER] -->
	<appender name="COMPONENT-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="File" value="${webapp.root}/logs/logistics-component.log" />
		<param name="Append" value="true" />
		<param name="encoding" value="GBK" />
		<param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern"
				value="%d{ISO8601} \u8017\u65f6\uff1a%r [\u65e5\u5fd7\u6765\u81ea\uff1a%-40.40c{3} \u65e5\u5fd7\u7c7b\u578b: %-5p \u65e5\u5fd7\u5185\u5bb9\uff1a%m]%n" />
		</layout>
	</appender>

	<!-- debug log -->
	<!-- name\u6307\u5b9a\u7684\u662f\u5305\u540d\uff0c\u8868\u793a\u8fd9\u4e2alogger\u53ea\u8bb0\u5f55com.wzw.controller\u4e0b\u7684\u6240\u6709\u65e5\u5fd7 -->
	<logger name="com.wzw.controller" additivity="true">  <!-- additivity \u662f\u5426\u7ee7\u627froot -->
		<!-- <level value="${loggingLevel}" /> -->
		<level value="DEBUG"></level>  <!-- \u73b0\u5728\u7ea7\u522b -->
		<appender-ref ref="DEBUG-APPENDER" />
	</logger>

	<!-- info log -->
	<!-- name\u6307\u5b9a\u7684\u662f\u5305\u540d\uff0c\u8fd9\u6837\u53ea\u64cd\u4f5c\u6b64\u5305\u4e0b\u7684log -->
	<logger name="org.dubbo.action" additivity="true">
		<level value="DEBUG"></level>
		<appender-ref ref="INFO-APPENDER" />
		<appender-ref ref="console" />
	</logger>

	<!-- Root Logger -->
	<!-- \u6240\u6709logger\u7684\u7236\u7c7b\uff0c\u8bb0\u5f55\u6240\u6709\u7684\u65e5\u5fd7\u3002 -->
	<root>
		<level value="ALL"></level>  <!-- \u9650\u5b9a\u8bb0\u5f55\u7b49\u7ea7 -->
		<appender-ref ref="DEFAULT-APPENDER" />  <!-- \u8c03\u7528\u8bb0\u5f55\u65b9\u5f0f -->
		<appender-ref ref="console" />
	</root>

</log4j:configuration>

然后是springmvc.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:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
            http://www.springframework.org/schema/mvc 
            http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-3.0.xsd 
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">
	<context:annotation-config />
	<context:component-scan base-package="org.dubbo.action">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
	</context:component-scan>

	<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
	<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
	<!-- 静态资源的访问 -->
	<!-- 视图分解器 -->
	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/" />
		<property name="suffix" value=".jsp" />
	</bean>
	<!-- 国际化的消息资源文件（本系统中主要用于显示/错误消息定制） -->
	<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
		<property name="basenames">
			<list>
				<!-- 在web环境中一定要定位到classpath 否则默认到当前web应用下找 -->
				<value>classpath:/messages</value>
			</list>
		</property>
		<property name="useCodeAsDefaultMessage" value="false" />
		<property name="defaultEncoding" value="UTF-8" />
		<property name="cacheSeconds" value="60" />
	</bean>

	<!-- 避免IE在ajax请求时，返回json出现下载 -->
	<bean id="jacksonMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
		<property name="supportedMediaTypes">
			<list>
				<value>text/html;charset=UTF-8</value>
			</list>
		</property>
	</bean>

	<!-- 上传文件的解析器 -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="defaultEncoding" value="utf-8" />
		<property name="maxUploadSize" value="10485760000" />
		<property name="maxInMemorySize" value="40960" />
	</bean>

	<import resource="classpath:dubbo_action.xml" />
</beans>

然后在是 index.jsp文件里面就一行代码简单的输出了一下 ${A.name}

好了到这里就可以简单的测试一把数据库查询了记住前面那个main 运行dubbo服务别关了，这里直接把action部署到tomcat上运行

然后浏览器上访问：提示这就说明 dubbo-springmvc-mybatis搭建完成了并且数据库也通，但是有的人直接按照我的配置来的话可能会出现连接错误，因为有的代码中设计到了 redis 所以在你运行这一步的时候最好保证配置好了redis 所以操作，并且我代码中有的你也有，最下面我会贴上源码的下载地址:

上面把redis 的配置文件都配好了但是没截 redis 的执行代码，，这里附上代码

RedisCache.java

package org.dubbo.api.redis;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

import redis.clients.jedis.exceptions.JedisConnectionException;

public class RedisCache implements Cache {
	/**
	 * 日志
	 */
	private static final Logger logger = LoggerFactory
			.getLogger(RedisCache.class);

	private static JedisConnectionFactory jedisConnectionFactory;

	private final String id;

	/**
	 * The {@code ReadWriteLock}.
	 */
	private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

	public RedisCache(final String id) {
		if (id == null) {
			throw new IllegalArgumentException("Cache instances require an ID");
		}
		logger.debug("MybatisRedisCache:id=" + id);
		this.id = id;
	}

	public void clear() {
		JedisConnection connection = null;
		try {
			connection = jedisConnectionFactory.getConnection();
			connection.flushDb();
			connection.flushAll();
		} catch (JedisConnectionException e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				connection.close();
			}
		}
	}

	public String getId() {
		return this.id;
	}

	public Object getObject(Object key) {
		Object result = null;
		JedisConnection connection = null;
		try {
			connection = jedisConnectionFactory.getConnection();
			RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
			result = serializer.deserialize(connection.get(serializer
					.serialize(key)));
		} catch (JedisConnectionException e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				connection.close();
			}
		}
		return result;
	}

	public ReadWriteLock getReadWriteLock() {
		// TODO Auto-generated method stub
		return this.readWriteLock;
	}

	public int getSize() {
		int result = 0;
		JedisConnection connection = null;
		try {
			connection = jedisConnectionFactory.getConnection();
			result = Integer.valueOf(connection.dbSize().toString());
		} catch (JedisConnectionException e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				connection.close();
			}
		}
		return result;
	}

	public void putObject(Object key, Object value) {
		JedisConnection connection = null;
		try {
			connection = jedisConnectionFactory.getConnection();
			RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
			connection.set(serializer.serialize(key),
					serializer.serialize(value));
		} catch (JedisConnectionException e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				connection.close();
			}
		}
	}

	public Object removeObject(Object key) {
		JedisConnection connection = null;
		Object result = null;
		try {
			connection = jedisConnectionFactory.getConnection();
			RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
			result = connection.expire(serializer.serialize(key), 0);
		} catch (JedisConnectionException e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				connection.close();
			}
		}
		return result;
	}

	public static void setJedisConnectionFactory(
			JedisConnectionFactory jedisConnectionFactory) {
		RedisCache.jedisConnectionFactory = jedisConnectionFactory;
	}

}

RedisCacheTransfer.java

package org.dubbo.api.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

/**
 * 
 * @描述: 静态注入中间类
 */
public class RedisCacheTransfer {

	@Autowired
	public void setJedisConnectionFactory(
			JedisConnectionFactory jedisConnectionFactory) {
		RedisCache.setJedisConnectionFactory(jedisConnectionFactory);
	}

}

SerializeUtil.java

package org.dubbo.api.redis;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {
	public static byte[] serialize(Object object) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream baos = null;
		try {
			// 序列化
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			byte[] bytes = baos.toByteArray();
			return bytes;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public static Object unserialize(byte[] bytes) {
		if (bytes == null)
			return null;
		ByteArrayInputStream bais = null;
		try {
			// 反序列化
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}


	/**
	 * 
	 * 反序列化
	 * 
	 * @param bytes
	 * @return
	 */
	public static Object unSerialize(byte[] bytes) {

		ByteArrayInputStream bais = null;

		try {
			// 反序列化为对象
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();

		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

好了这里所有的代码就全部完了，，至于那个User类我就不截图了，，

正常来说在没配置 redis 之前执行那个查询 IDE后台是会打印执行的sql语句的我这里直接配置了因为之前执行过所以我这里直接读的是缓存里面的而不是读的数据库里面的如图所示：

忘了说想看是不是走的缓存你得先在命令行执行定位到 redis当前所在目录然后在执行:

这是源代码的下载地址: 这个可能有点坑要1积分，，没办法在csdn上传的资源最低要求1 积分：http://download.csdn.net/download/wangbo54979/9960339 后续会把代码上传到git上，，在更新下载地址 https://github.com/wb90/test-model

wb54979

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
spring-springmvc-mybatis-dubbo-redis-mysql实现soa搭建,数据查询,数据缓存

spring-springmvc-mybatis-dubbo-redis-mysql 执行搭建数据查询缓存
复制链接

扫一扫

专栏目录