目录
  1. 1. 开篇 BEGIN
    1. 1.1. 1、做什么?怎么做?
    2. 1.2. 2、项目结构
    3. 1.3. 3、POM.XML
    4. 1.4. 4、核心配置
    5. 1.5. 5、业务控制器
    6. 1.6. 6、关键服务类
    7. 1.7. 7、Redis 的使用
    8. 1.8. 8、Druid 监控配置
    9. 1.9. 9、结果展示
    10. 1.10. 10、THE END
实战(一):SpringMvc+Hibernate+Druid+Redis

@TOC

开篇 BEGIN

实战系列作为作为个人平时练习的项目代码的记录,出这个系列主要是以下几个目的:

  • 首先方便自己后续的查阅,包括像核心配置文件的获取等等
  • 再者就是和大家分享,希望对您的工作有所帮助
  • 最后就是能够加深理解,“理论+实践”的组合是永远不会过时的套路

这第一篇的实践给到了我们的SpringMvc+Hibernate+Druid+Redis,理论知识的获取可以从我的其他文章进行查看!

1、做什么?怎么做?

用这些东西我们要做出一个什么东西呢?我们的需求很简单:首先实现一个用户的注册和登陆,登陆后可以进行用户列表的维护。再者用户能够在首页查看公告的新闻,而为了避免频繁的访问数据库,首页的这个公告要能够缓存起来,最后就是要求对系统的行为做到一定程度的监控。

怎么做呢?我们想想,首先登陆、注册,就是用户的增、改、查,维护无非就是删除,所以一个Hibernate搞定了。公告新闻还带缓存,Redis就出场了,监控数据行为,Druid自带不用都浪费了。以上的这些都依托在SpringMvc的大的基础架构下就形成了这样一幅篇章。

好了,话不多说,一起看下吧!(下文涉及大量程序代码及其配置,概念理论主义者慎入哈!!!)

2、项目结构

在这里插入图片描述
项目整体结构如上图(怎么简单怎么来~),我选择的是Maven来进行整个项目依赖的整合以及Jar包的管理

3、POM.XML

添加我们需要引用的Jar包,主要就是Spring以及SpringMvc相关jar包的引入。我这边没有给出框架最精简的jar包,如果有需要,请酌情删减!

1
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
2
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3
  <!-- Maven相关通用配置 -->
4
  <modelVersion>4.0.0</modelVersion>
5
  <groupId>SpringTest</groupId>
6
  <artifactId>SpringTest</artifactId>
7
  <version>0.0.1-SNAPSHOT</version>
8
  <packaging>war</packaging>
9
  <name>SpringTest</name>
10
  <description/>
11
  
12
  <!-- 先定义系列jar包版本,在下面引用(推荐使用)(此处练习测试没有按照规范进行) -->
13
  <properties>
14
    <webVersion>3.1</webVersion>
15
    <druid.version>1.1.10</druid.version>
16
    <hibernate.version>4.3.11.Final</hibernate.version>
17
	<hibernate.validator.version>5.4.1.Final</hibernate.validator.version>
18
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
19
    <jackson.version>1.8.4</jackson.version>
20
    <jackson-databind.version>2.5.1</jackson-databind.version>
21
  </properties>
22
  
23
  <!-- 涉及jar包 -->
24
  <dependencies>
25
    <dependency>
26
      <groupId>javax</groupId>
27
      <artifactId>javaee-api</artifactId>
28
      <version>7.0</version>
29
      <scope>provided</scope>
30
    </dependency>
31
    <dependency>
32
      <groupId>org.glassfish.web</groupId>
33
      <artifactId>javax.servlet.jsp.jstl</artifactId>
34
      <version>1.2.2</version>
35
    </dependency>
36
    <dependency>
37
      <groupId>org.springframework</groupId>
38
      <artifactId>spring-aop</artifactId>
39
      <version>4.1.0.RELEASE</version>
40
    </dependency>
41
    <dependency>
42
      <groupId>org.springframework</groupId>
43
      <artifactId>spring-aspects</artifactId>
44
      <version>4.1.0.RELEASE</version>
45
    </dependency>
46
    <dependency>
47
      <groupId>org.springframework</groupId>
48
      <artifactId>spring-beans</artifactId>
49
      <version>4.1.0.RELEASE</version>
50
    </dependency>
51
    <dependency>
52
      <groupId>org.springframework</groupId>
53
      <artifactId>spring-context</artifactId>
54
      <version>4.1.0.RELEASE</version>
55
    </dependency>
56
    <dependency>
57
      <groupId>org.springframework</groupId>
58
      <artifactId>spring-context-support</artifactId>
59
      <version>4.1.0.RELEASE</version>
60
    </dependency>
61
     <dependency>
62
      <groupId>org.springframework</groupId>
63
      <artifactId>spring-jdbc</artifactId>
64
      <version>4.1.0.RELEASE</version>
65
    </dependency>
66
    <dependency>
67
      <groupId>org.springframework</groupId>
68
      <artifactId>spring-expression</artifactId>
69
      <version>4.1.0.RELEASE</version>
70
    </dependency>
71
    <dependency>
72
      <groupId>org.springframework</groupId>
73
      <artifactId>spring-instrument</artifactId>
74
      <version>4.1.0.RELEASE</version>
75
    </dependency>
76
    <dependency>
77
      <groupId>org.springframework</groupId>
78
      <artifactId>spring-instrument-tomcat</artifactId>
79
      <version>4.1.0.RELEASE</version>
80
    </dependency>
81
    <dependency>
82
      <groupId>org.springframework</groupId>
83
      <artifactId>spring-core</artifactId>
84
      <version>4.1.0.RELEASE</version>
85
    </dependency>
86
    <dependency>
87
      <groupId>aopalliance</groupId>
88
      <artifactId>aopalliance</artifactId>
89
      <version>1.0</version>
90
    </dependency>
91
    <dependency>
92
      <groupId>commons-pool</groupId>
93
      <artifactId>commons-pool</artifactId>
94
      <version>1.6</version>
95
    </dependency>
96
    <dependency>
97
		<groupId>commons-io</groupId>
98
		<artifactId>commons-io</artifactId>
99
		<version>2.2</version>
100
	</dependency>
101
    <dependency>
102
      <groupId>log4j</groupId>
103
      <artifactId>log4j</artifactId>
104
      <version>1.2.17</version>
105
    </dependency>
106
    <dependency>
107
      <groupId>org.aspectj</groupId>
108
      <artifactId>aspectjweaver</artifactId>
109
      <version>1.8.2</version>
110
    </dependency>
111
    <dependency>
112
      <groupId>org.springframework</groupId>
113
      <artifactId>spring-web</artifactId>
114
      <version>4.1.0.RELEASE</version>
115
    </dependency>
116
    <dependency>
117
      <groupId>org.springframework</groupId>
118
      <artifactId>spring-webmvc</artifactId>
119
      <version>4.1.0.RELEASE</version>
120
    </dependency>
121
    <dependency>
122
      <groupId>org.springframework</groupId>
123
      <artifactId>spring-webmvc-portlet</artifactId>
124
      <version>4.1.0.RELEASE</version>
125
    </dependency>
126
    <dependency>
127
      <groupId>org.springframework</groupId>
128
      <artifactId>spring-jms</artifactId>
129
      <version>4.1.0.RELEASE</version>
130
    </dependency>
131
    <dependency>
132
      <groupId>org.springframework</groupId>
133
      <artifactId>spring-oxm</artifactId>
134
      <version>4.1.0.RELEASE</version>
135
    </dependency>
136
    <dependency>
137
      <groupId>org.springframework.webflow</groupId>
138
      <artifactId>spring-webflow</artifactId>
139
      <version>2.4.0.RELEASE</version>
140
    </dependency>
141
    <dependency>
142
      <groupId>org.springframework.webflow</groupId>
143
      <artifactId>spring-binding</artifactId>
144
      <version>2.4.0.RELEASE</version>
145
    </dependency>
146
    <dependency>
147
      <groupId>org.springframework.webflow</groupId>
148
      <artifactId>spring-js</artifactId>
149
      <version>2.4.0.RELEASE</version>
150
    </dependency>
151
    <dependency>
152
      <groupId>org.springframework.webflow</groupId>
153
      <artifactId>spring-js-resources</artifactId>
154
      <version>2.4.0.RELEASE</version>
155
    </dependency>
156
    <dependency>
157
      <groupId>opensymphony</groupId>
158
      <artifactId>ognl</artifactId>
159
      <version>2.6.11</version>
160
    </dependency>
161
    
162
    <!-- 以上是集成SpringMVC涉及Jar包,以下是自定义jar包 -->
163
    
164
    <!-- 引入阿里的数据源连接池 -->
165
	<dependency>
166
		<groupId>com.alibaba</groupId>
167
		<artifactId>druid</artifactId>
168
		<version>${druid.version}</version>
169
	</dependency>
170
	
171
	<!-- 导入hibernate持久层框架JAR包 -->
172
	<dependency>
173
		<groupId>org.hibernate</groupId>
174
		<artifactId>hibernate-core</artifactId>
175
		<version>${hibernate.version}</version>
176
	</dependency>
177
178
	<!-- 引入hibernate的验证框架 -->
179
	<dependency>
180
		<groupId>org.hibernate</groupId>
181
		<artifactId>hibernate-validator</artifactId>
182
		<version>${hibernate.validator.version}</version>
183
	</dependency>
184
	<!-- 导入spring容器整合ORM框架的相关JAR文件 -->
185
	<dependency>
186
		<groupId>org.springframework</groupId>
187
		<artifactId>spring-orm</artifactId>
188
		<version>4.1.0.RELEASE</version>
189
	</dependency>
190
191
	<!-- 引入spring框架与ehcache框架的兼容JAR包 -->
192
	<dependency>
193
		<groupId>org.springframework</groupId>
194
		<artifactId>spring-context-support</artifactId>
195
		<version>4.1.0.RELEASE</version>
196
	</dependency>
197
198
	<!-- 引入ehcache二级缓存相关JAR包 -->
199
	<dependency>
200
		<groupId>net.sf.ehcache</groupId>
201
		<artifactId>ehcache-core</artifactId>
202
		<version>2.4.3</version>
203
	</dependency>
204
	
205
	<!-- xml操作相关 -->
206
	<dependency>
207
	    <groupId>xml-apis</groupId>
208
	    <artifactId>xml-apis</artifactId>
209
	    <version>1.4.01</version>
210
	</dependency>
211
	
212
	<!-- mysql -->
213
	<dependency>
214
		<groupId>mysql</groupId>
215
		<artifactId>mysql-connector-java</artifactId>
216
		<version>5.1.47</version>
217
		<scope>runtime</scope>
218
	</dependency>
219
	
220
	<!-- dbcp连接池 -->
221
	<dependency>
222
		<groupId>commons-dbcp</groupId>
223
		<artifactId>commons-dbcp</artifactId>
224
		<version>1.4</version>
225
		<scope>compile</scope>
226
	</dependency>
227
	
228
	<dependency>
229
		<groupId>commons-beanutils</groupId>
230
		<artifactId>commons-beanutils</artifactId>
231
		<version>1.7.0</version>
232
		<exclusions>
233
			<exclusion>
234
				<groupId>commons-logging</groupId>
235
				<artifactId>commons-logging</artifactId>
236
			</exclusion>
237
		</exclusions>
238
	</dependency>
239
	
240
	<!-- redis缓存相关 -->
241
	<dependency>
242
		<groupId>org.springframework.data</groupId>
243
		<artifactId>spring-data-redis</artifactId>
244
		<version>1.6.2.RELEASE</version>
245
	</dependency>
246
	<dependency>
247
	    <groupId>redis.clients</groupId>
248
	    <artifactId>jedis</artifactId>
249
	    <version>2.9.0</version>
250
	</dependency>
251
	<dependency>  
252
	    <groupId>com.fasterxml.jackson.core</groupId>  
253
	    <artifactId>jackson-databind</artifactId>  
254
	    <version>${jackson-databind.version}</version>  
255
	</dependency>
256
	<dependency>
257
		<groupId>commons-lang</groupId>
258
		<artifactId>commons-lang</artifactId>
259
		<version>2.6</version>
260
	</dependency>
261
		
262
  </dependencies>
263
  
264
  <!-- build 相关配置 -->
265
  <build>
266
    <sourceDirectory>src</sourceDirectory>
267
    <resources>
268
      <resource>
269
        <directory>src</directory>
270
        <excludes>
271
          <exclude>**/*.java</exclude>
272
        </excludes>
273
      </resource>
274
    </resources>
275
    <plugins>
276
      <plugin>
277
        <artifactId>maven-compiler-plugin</artifactId>
278
        <version>2.3.2</version>
279
        <configuration>
280
          <source>1.7</source>
281
          <target>1.7</target>
282
        </configuration>
283
      </plugin>
284
      <plugin>
285
        <artifactId>maven-war-plugin</artifactId>
286
        <version>2.6</version>
287
        <configuration>
288
          <warSourceDirectory>${basedir}/WebRoot</warSourceDirectory>
289
          <failOnMissingWebXml>false</failOnMissingWebXml>
290
        </configuration>
291
      </plugin>
292
    </plugins>
293
  </build>
294
</project>

4、核心配置

Web程序的配置,当然是要从web.xml开启,那么以下就是相关配置

1
<?xml version="1.0" encoding="UTF-8"?>
2
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
3
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
4
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
5
  	<!-- 显示名 -->
6
  	<display-name>SpringTest</display-name>
7
  	
8
  	<!-- 字符过滤器  -->
9
	<filter>
10
		<description>字符集过滤器</description>
11
		<filter-name>encodingFilter</filter-name>
12
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
13
		<init-param>
14
			<description>字符集编码</description>
15
			<param-name>encoding</param-name>
16
			<param-value>UTF-8</param-value>
17
		</init-param>
18
	</filter>
19
	<filter-mapping>
20
		<filter-name>encodingFilter</filter-name>
21
		<url-pattern>/*</url-pattern>
22
	</filter-mapping>
23
	
24
	
25
	<!-- druid 相关配置  BEGIN -->
26
	<!-- web 监听配置 -->
27
	<filter>
28
		<filter-name>druidWebStatFilter</filter-name>
29
		<filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
30
		<init-param>
31
			<param-name>exclusions</param-name>
32
			<param-value>/css/*,/context/*,/plug-in/*,*.js,*.css,*/druid*,/attached/*,*.jsp</param-value>
33
		</init-param>
34
		<init-param>
35
			<param-name>principalSessionName</param-name>
36
			<param-value>sessionInfo</param-value>
37
		</init-param>
38
		<init-param>
39
			<param-name>sessionStatEnable</param-name>
40
			<param-value>false</param-value>
41
		</init-param>
42
		<init-param>
43
			<param-name>profileEnable</param-name>
44
			<param-value>true</param-value>
45
		</init-param>
46
	</filter>
47
	<filter-mapping>
48
		<filter-name>druidWebStatFilter</filter-name>
49
		<url-pattern>/*</url-pattern>
50
	</filter-mapping>
51
  	<!-- 启用自带的系统监听展示 -->
52
	<servlet>
53
		<servlet-name>druidStatView</servlet-name>
54
		<servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
55
	</servlet>
56
	<servlet-mapping>
57
		<servlet-name>druidStatView</servlet-name>
58
		<url-pattern>/webpage/system/druid/*</url-pattern>
59
	</servlet-mapping>
60
  	<!-- druid 相关配置  END -->
61
  
62
  
63
  	<!-- Spring 相关配置  BEGIN  -->
64
  	<!-- Spring 上下文监听 -->
65
  	<listener>
66
	    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
67
  	</listener>
68
  	<!-- Spring 配置文件路径 -->
69
	<context-param>
70
		<param-name>contextConfigLocation</param-name>
71
		<param-value>classpath:applicationContext.xml</param-value>
72
 	</context-param>
73
 	<!-- Spring 核心调度器servlet -->
74
  	<servlet>
75
        <servlet-name>dispatcher</servlet-name>
76
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
77
        <init-param>  
78
            <param-name>contextConfigLocation</param-name>  
79
            <param-value>classpath:applicationContext.xml</param-value>  
80
        </init-param> 
81
    </servlet>
82
    <servlet-mapping>
83
        <servlet-name>dispatcher</servlet-name>
84
        <url-pattern>*.do</url-pattern>
85
    </servlet-mapping>
86
    <!-- Spring 相关配置  END  -->
87
</web-app>

然后就是SpringMvc的核心配置文件了,applicationContext.xml,如下:

1
<?xml version="1.0" encoding="UTF-8"?>
2
<beans
3
	xmlns="http://www.springframework.org/schema/beans"
4
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5
    xmlns:context="http://www.springframework.org/schema/context"
6
    xmlns:mvc="http://www.springframework.org/schema/mvc"
7
    xmlns:tx="http://www.springframework.org/schema/tx"
8
    xmlns:aop="http://www.springframework.org/schema/aop"
9
    xmlns:p="http://www.springframework.org/schema/p"
10
	xmlns:cache="http://www.springframework.org/schema/cache"
11
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
12
    http://www.springframework.org/schema/beans/spring-beans.xsd
13
        http://www.springframework.org/schema/context 
14
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
15
        http://www.springframework.org/schema/aop 
16
        http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
17
        http://www.springframework.org/schema/tx 
18
        http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
19
        http://www.springframework.org/schema/mvc 
20
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
21
        http://www.springframework.org/schema/cache 
22
        http://www.springframework.org/schema/cache/spring-cache-4.1.xsd">
23
24
	<!-- spring 配置  BENGIN -->
25
	<!-- 注解扫描配置,定义要扫描的路径,完成注入  -->
26
    <context:component-scan base-package="com.springtest.*" />
27
    <!-- 处理器映射器  -->
28
	<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
29
	<!-- 处理器适配器 -->
30
	<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
31
    <!-- 视图解析器配置 -->
32
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
33
     id="internalResourceViewResolver">
34
           <!-- 定义视图前缀(路径) -->
35
           <property name="prefix" value="/webpage/" />
36
           <!-- 定义视图后缀(格式) -->
37
           <property name="suffix" value=".jsp" />
38
    </bean>
39
    <!-- spring 配置  END -->
40
    
41
    
42
    
43
    <!-- Hibernate 配置  BEGIN -->
44
    <!-- 外部的数据库配置文件 -->
45
	<context:property-placeholder location="classpath:dbconfig.properties" />
46
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
47
		<property name="dataSource" ref="dataSource"></property>
48
		<!-- 自动扫描路径配置(此处简单配置全局) -->
49
		<property name="packagesToScan">
50
			<list>
51
				<value>com.springtest.*</value>
52
			</list>
53
		</property>
54
 
55
		<!--  hibernate相关配置 -->
56
		<property name="hibernateProperties">
57
			<props>
58
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
59
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
60
				<prop key="hibernate.show_sql">true</prop>
61
				<prop key="hibernate.format_sql">true</prop>
62
				<prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
63
			</props>
64
		</property>
65
	</bean>
66
	<!-- 配置事务管理器 -->
67
	<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
68
		<property name="sessionFactory" ref="sessionFactory" />
69
	</bean>
70
	
71
	<!-- 配置事物管理器,通过@Transactional就可以启用事物管理 -->
72
	<tx:annotation-driven transaction-manager="transactionManager" />
73
    
74
    <!-- 配置hibernate模板操作类 -->
75
	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate4.HibernateTemplate">
76
		<property name="sessionFactory" ref="sessionFactory"></property>
77
	</bean>
78
	<!-- Hibernate 配置  END -->
79
	
80
	
81
	<!-- DRUID 配置  BEGIN -->
82
    <!-- 连接池配置 ,destroy-method="close" :代表spring容器在销毁时,调用close(),关闭掉所有的数据库连接对象-->
83
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" 
84
											init-method="init" destroy-method="close">
85
		<!-- 配置连接数据库最基本的3元素 (驱动可忽略) -->
86
		<property name="url" value="${jdbc.url}" />
87
		<property name="username" value="${jdbc.username}" />
88
		<property name="password" value="${jdbc.password}" />
89
		<!-- 最大连接数 -->
90
		<property name="maxActive" value="20" />
91
		<!-- 初始化数量 -->
92
		<property name="initialSize" value="1" />
93
		<!-- 创建连接的超时时间,单位:毫秒 -->
94
		<property name="maxWait" value="60000" />
95
		<!-- 最小连接数 -->
96
		<property name="minIdle" value="1" />
97
		<!-- 配置校验语句 -->
98
		<property name="validationQuery" value="${validationQuery.sql}" />
99
		<!-- 配置校验(连接空闲时,借出时,归还时) -->
100
		<property name="testWhileIdle" value="true" />
101
		<property name="testOnBorrow" value="false" />
102
		<property name="testOnReturn" value="false" />
103
		<!-- 配置是否允许PreparedStatements对象的缓存 -->
104
		<property name="poolPreparedStatements" value="true" />
105
		<property name="maxOpenPreparedStatements" value="20" />
106
		<!-- 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒 -->
107
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
108
		<!-- 配置一个连接在池中最小生存的时间,单位是毫秒 -->
109
		<property name="minEvictableIdleTimeMillis" value="300000" />
110
		<!-- 配置连接池中,创建连接时,采用异步|同步方式来进行创建,默认是:异步 -->
111
		<property name="asyncInit" value="true" />
112
		<!-- 配置额外的扩展插件:stat 代表开启监控程序,wall 代表开启防SQL注入功能 -->
113
		<property name="filters" value="wall,stat" />
114
		<!-- 打开removeAbandoned功能 -->
115
		<property name="removeAbandoned" value="true" />
116
		<!-- 1800秒,也就是30分钟 -->
117
		<property name="removeAbandonedTimeout" value="3600" />
118
		<!-- 关闭abanded连接时输出错误日志 -->
119
		<property name="logAbandoned" value="true" />
120
		<!-- 如果有定制化的过滤器,可以使用proxyFilters 去做一个引用 -->
121
		<property name="proxyFilters">
122
			<list>
123
				<ref bean="stat-filter" />
124
				<ref bean="log-filter" />
125
			</list>
126
		</property>
127
		<!-- Oracle连接是获取字段注释 -->
128
		<property name="connectProperties">
129
			<props>
130
				<prop key="remarksReporting">true</prop>
131
			</props>
132
		</property>
133
	</bean>
134
    <!-- 定制化的监控过滤器 -->
135
	<bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
136
		<property name="slowSqlMillis" value="200" />
137
		<property name="logSlowSql" value="true" />
138
	</bean>
139
    <!-- 定制化的日志过滤器 -->
140
	<bean id="log-filter" class="com.alibaba.druid.filter.logging.Log4jFilter">
141
		<!-- 开启数据源相关的日志记录 -->
142
		<property name="dataSourceLogEnabled" value="true" />
143
		<!-- 连接错误时,记录相关日志 -->
144
		<property name="connectionLogErrorEnabled" value="true"></property>
145
		<!-- 预编译对象,发生错误时记录相关日志 -->
146
		<property name="statementLogErrorEnabled" value="true"></property>
147
	</bean>
148
	<!-- druid支持spring监控 -->
149
	<bean id="druid-stat-interceptor"
150
		class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">
151
	</bean>
152
	<bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"
153
		scope="prototype">
154
		<property name="patterns">
155
			<list>
156
				<value>com.springtest.*</value>
157
			</list>
158
		</property>
159
	</bean>
160
	<aop:config>
161
		<aop:advisor advice-ref="druid-stat-interceptor" pointcut-ref="druid-stat-pointcut" />
162
	</aop:config>
163
	<!-- DRUID 配置  END -->
164
	
165
	
166
	<!-- JDBC配置  BEGIN-->
167
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
168
		<property name="dataSource">
169
			<ref bean="dataSource" />
170
		</property>
171
	</bean>
172
	<!-- JDBC配置  END-->
173
	
174
	<!-- 缓存配置  BEGIN-->
175
	<!-- Hibernate缓存配置 -->
176
	<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager" 
177
	p:cache-manager-ref="ehcache" />
178
	<!-- spring缓存配置 -->
179
	<bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" 
180
	p:config-location="classpath:ehcache.xml" />
181
	<!-- 导入Redis缓存配置 -->
182
	<import resource="classpath:springtest-redis.xml" />
183
	<!-- 缓存配置  END-->
184
    
185
   	<!-- 其他配置  BEGIN-->
186
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
187
	<!-- 其他配置  END-->
188
</beans>

因为我们还用到了Redis,所以必不可少要对其做相应的配置,如下:

1
<?xml version="1.0" encoding="UTF-8"?>
2
<beans xmlns="http://www.springframework.org/schema/beans"
3
    xmlns:context="http://www.springframework.org/schema/context" 
4
    xmlns:p="http://www.springframework.org/schema/p"
5
    xmlns:cache="http://www.springframework.org/schema/cache" 
6
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
7
    xmlns:redis="http://www.springframework.org/schema/redis"
8
    xsi:schemaLocation="
9
     http://www.springframework.org/schema/beans 
10
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
11
     http://www.springframework.org/schema/context 
12
     http://www.springframework.org/schema/context/spring-context-3.1.xsd
13
     http://www.springframework.org/schema/cache 
14
     http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
15
     http://www.springframework.org/schema/redis
16
     http://www.springframework.org/schema/redis/spring-redis-1.0.xsd">
17
     
18
    <!-- jedis 配置 BEGIN-->
19
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
20
        <!-- 最大空闲连接数 -->
21
        <property name="maxIdle" value="300" />
22
        <!-- 最小空闲连接数 -->
23
        <property name="minIdle" value="1" />
24
        <property name="maxWaitMillis" value="1000" />
25
        <!-- 在获取连接的时候检查有效性 -->
26
        <property name="testOnBorrow" value="false" />
27
    </bean>
28
    <!-- jedis 配置 END-->
29
    
30
    <!-- redis服务器中心  BEGIN-->
31
    <bean id="redisConnectionFactory" 
32
    class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
33
        <property name="poolConfig" ref="poolConfig" />
34
        <property name="port" value="6379" />
35
        <property name="hostName" value="127.0.0.1" />
36
        <property name="timeout" value="10000" />
37
        <property name="database" value="0" />
38
    </bean>
39
    <!-- redis服务器中心 END-->
40
    
41
	<!-- redis模板 BEGIN-->
42
	<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"> 
43
    	<property name="connectionFactory" ref="redisConnectionFactory" /> 
44
        <property name="keySerializer">
45
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
46
        </property>
47
        <property name="valueSerializer">
48
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
49
        </property>
50
        <property name="hashKeySerializer">
51
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
52
        </property>
53
        <property name="hashValueSerializer">
54
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
55
        </property>
56
  	</bean>
57
  	
58
  	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
59
	    <property name="connectionFactory" ref="redisConnectionFactory"/>  
60
	    <property name="keySerializer">
61
	        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
62
	    </property>
63
	    <property name="hashKeySerializer">
64
	        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
65
	    </property>
66
	    <property name="valueSerializer">
67
	        <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
68
	    </property>
69
	    <property name="hashValueSerializer">
70
	        <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
71
	    </property>
72
	</bean> 
73
  	<!-- redis模板 END-->
74
</beans>

好了,配置大功告成,接下来看看其他的组件吧

5、业务控制器

这边给出首页的控制器,这里面包含有Hibernate、Jedis(Java 操作Redis组件)的应用,如下:

1
/***
2
 * index 控制器 
3
 * @author hjf
4
 * @version 练习版本,无任何优化处理,仅供参考
5
 * @date 2018-05-10
6
 */
7
@Controller
8
@RequestMapping("/index")
9
public class IndexController {
10
11
	/**
12
	 * 初始化Log4j的一个实例
13
	 */
14
	private static final Logger logger = Logger.getLogger(IndexController.class);
15
	
16
	@Autowired
17
	private ICommonDBService commonDBService;
18
	@Autowired
19
	private IRedisService redisService;
20
	// 新闻缓存的Key值
21
	private static final String NEWS_REDIS_KEY = "NEWS_REDIS_KEY";
22
	
23
	/**
24
	 * 登陆页面
25
	 * @return
26
	 */
27
	@RequestMapping(params = "login")  
28
    public ModelAndView login() {  
29
        return new ModelAndView("login"); 
30
    }
31
	
32
	/***
33
	 * 注册页面
34
	 * @return
35
	 */
36
	@RequestMapping(params = "register")  
37
    public ModelAndView register() {  
38
        return new ModelAndView("register"); 
39
    }
40
	
41
	/**
42
	 * 验证登陆
43
	 * 1、验证用户名密码是否正确
44
	 * 2、封装首页信息并返回
45
	 * @param username	用户名
46
	 * @param userpwd	密码
47
	 * @return
48
	 */
49
	@RequestMapping(params = "doLogin")
50
	public String doLogin(String username,String userpwd,HttpServletRequest request){
51
		try {
52
			if(StringUtils.isEmpty(username) || StringUtils.isEmpty(userpwd)){
53
				return "login_fail";
54
			}
55
			//1、 进行用户身份认证
56
			User user = commonDBService.findHqlOne(User.class, " from User where username = ? ", username);
57
			if(user == null){
58
				return "login_fail";
59
			}
60
			if(StringUtils.isNotBlank(user.getPassword()) && user.getPassword().equals(userpwd)){
61
				//2、用户信息认证成功,封装首页数据
62
				//2.1、 查找用户列表
63
				List<User> memberList = commonDBService.findHql(" from User where username != ?",username);
64
				if(memberList == null){
65
					memberList = new ArrayList<User>();
66
				}
67
				request.setAttribute("memberList", memberList);
68
				
69
				//2.2、获取热点新闻列表,首先通过Redis获取,如果能获取到直接返回
70
				//如果获取不到则去数据库获取并更新热点新闻
71
				List<Object> tList = redisService.getList(NEWS_REDIS_KEY);    //将列表设置到缓存
72
				List<News> list = new ArrayList<News>();
73
				if(tList != null && tList.size() > 0){
74
					//直接从Redis缓存取数据
75
					for (Object item : tList) {
76
						list.add((News) item);	
77
					}
78
					System.out.println("从缓存获取首页数据");
79
				} else {
80
					//缓存中无数据,从数据库中进行获取
81
					list = commonDBService.findAll(News.class);
82
					if(list != null){
83
						//将取出的数据缓存到Redis并设置过期时间
84
						redisService.setList(NEWS_REDIS_KEY, list, 6000);
85
						System.out.println("从数据库获取首页数据");
86
					}
87
				}
88
				request.setAttribute("newsList", list);
89
				return "index";
90
			}
91
			return "login_fail";
92
		} catch (Exception e) {
93
			logger.error(e);
94
		}
95
		return "login_fail";
96
	}
97
	
98
	/**
99
	 * 执行注册
100
	 * @param username 用户名
101
	 * @param userpwd  密码
102
	 * @return
103
	 */
104
	@RequestMapping(params = "doRegister")
105
	public String doRegister(String username,String userpwd){
106
		if(StringUtils.isEmpty(username) || StringUtils.isEmpty(userpwd)){
107
			return "register_fail";
108
		}
109
		User user = new User();
110
		user.setId(username);
111
		user.setUsername(username);
112
		user.setPassword(userpwd);
113
		commonDBService.save(user);
114
		return "login";
115
	}
116
	
117
	@RequestMapping(params = "doDelete")
118
	public String doDelete(String username){
119
		if(StringUtils.isEmpty(username) ){
120
			return "login_fail";
121
		}
122
		User user = commonDBService.findOneByProperty(User.class, "username", username);
123
		if(user == null){
124
			return "login_fail";
125
		}
126
		commonDBService.delete(user);
127
		return "index";
128
	}
129
}

6、关键服务类

贴出DB的关键服务类,主要用来集成Hibernate和Jdbc来操作数据库

1
@Service("commonDBService")
2
@Transactional
3
public class CommonDBServiceImpl implements ICommonDBService {
4
	
5
	@Autowired
6
	public ICommonDBDao commonDao = null;
7
8
	@Resource
9
	public void setCommonDao(ICommonDBDao commonDao) {
10
		this.commonDao = commonDao;
11
	}
12
	
13
	/********************Hibernate模块************************************/
14
	/**
15
	 * 获取session
16
	 * 2018-05-17
17
	 * @author hjf
18
	 * @return 返回session对象
19
	 */
20
	public Session getSession()	{
21
		return commonDao.getSession();
22
	}
23
	
24
	/**
25
	 * 保存对象 
26
	 * 2018-05-17
27
	 * @author hjf
28
	 * @param entity 要保存的实体 
29
	 * @return	保存后的实体Id 
30
	 */
31
	public <T> Serializable save(T entity) {
32
		return commonDao.save(entity);
33
	}
34
	
35
	/**
36
	 * 批量保存
37
	 * 2018-05-17
38
	 * @author hjf
39
	 * @param entityList 要保存的实体列表
40
	 * @return 
41
	 */
42
	public <T> void batchSave(List<T> entitys) {
43
		this.commonDao.batchSave(entitys);
44
	}
45
46
	/**
47
	 * 保存或更新实体 
48
	 * 2018-05-17
49
	 * @author hjf
50
	 * @param entity 要保存的实体对象
51
	 * @return 
52
	 */
53
	public <T> void saveOrUpdate(T entity) {
54
		commonDao.saveOrUpdate(entity);
55
	}
56
57
	/**
58
	 * 删除实体
59
	 * 2018-05-17
60
	 * @author hjf
61
	 * @param entity 要删除的实体
62
	 * @return 
63
	 */
64
	public <T> void delete(T entity) {
65
		commonDao.delete(entity);
66
	}
67
	
68
	/**
69
	 * 通过主键Key获取实体 
70
	 * 2018-05-17
71
	 * @author hjf
72
	 * @param clazz 要获取实体类型
73
	 * @param id 主键Key
74
	 * @return 实体对象
75
	 */
76
	public <T> T get(Class<T> clazz, Serializable id) {
77
		return commonDao.get(clazz, id);
78
	}
79
80
	/**
81
	 * 通过主键Key获取实体 
82
	 * 2018-05-17
83
	 * @author hjf
84
	 * @param clazz 要获取实体类型
85
	 * @param id 主键Key
86
	 * @return 实体对象
87
	 */
88
	public <T> T getEntity(Class<T> clazz, Serializable id){
89
		return commonDao.get(clazz, id);
90
	}
91
	
92
	/**
93
	 * 离线获取列表
94
	 * 2018-05-17
95
	 * @author hjf
96
	 * @param dc 查询载体
97
	 * @return 实体列表
98
	 */
99
	public <T> List<T> findByDetached(DetachedCriteria dc) {
100
		return this.commonDao.findByDetached(dc);
101
	}
102
	
103
	/**
104
	 * Hql查找实体列表
105
	 * 2018-05-17
106
	 * @author hjf
107
	 * @param hql hql语句
108
	 * @param 参数列表
109
	 * @return 实体列表
110
	 */
111
	public <T> List<T> findHql(String hql, Object... param) {
112
		return this.commonDao.findHql(hql, param);
113
	}
114
	
115
	/**
116
	 * Hql查找单一实体
117
	 * 2018-05-17
118
	 * @author hjf
119
	 * @param clazz 实体类型
120
	 * @param hql 查询语句
121
	 * @param param 参数列表
122
	 * @return	实体对象 
123
	 */
124
	public <T> T findHqlOne(Class<T> clazz,String hql, Object... param) {
125
		return this.commonDao.findHqlOne(clazz, hql, param);
126
	}
127
	
128
	/**
129
	 * Hql返回指定条数的实体
130
	 * 2018-05-17
131
	 * @author hjf
132
	 * @param hql 查询语句
133
	 * @param size 返回的条数
134
	 * @param param 参数列表
135
	 * @return 
136
	 */
137
	public <T> List<T> findLimitHql(String hql,int size, Object... param) {
138
		return this.commonDao.findLimitHql(hql,size, param);
139
	}
140
	
141
	/**
142
	 * 通过属性返回唯一实体
143
	 * 2018-05-17
144
	 * @author hjf
145
	 * @param clazz 实体类型
146
	 * @param propertyName 属性名册合格
147
	 * @param value 属性值
148
	 * @return 实体对象
149
	 */
150
	public <T> T findOneByProperty(Class<T> clazz, String propertyName, Object value) {
151
		return commonDao.findUniqueByProperty(clazz, propertyName, value);
152
	}
153
	
154
	/**
155
	 * 通过属性获取实体列表 
156
	 * 2018-05-17
157
	 * @author hjf
158
	 * @param clazz 实体类型
159
	 * @param propertyName 属性名称
160
	 * @param value 属性值
161
	 * @return 实体列表
162
	 */
163
	public <T> List<T> findByProperty(Class<T> clazz, String propertyName, Object value) {
164
		return commonDao.findByProperty(clazz, propertyName, value);
165
	}
166
	
167
	/**
168
	 * 通过主键删除实体 
169
	 * 2018-05-17
170
	 * @author hjf
171
	 * @param clazz 实体类型
172
	 * @param id 主键Key
173
	 * @return 
174
	 */
175
	public <T> void deleteEntity(Class<T> clazz, Serializable id) {
176
		commonDao.deleteEntity(clazz, id);
177
	}
178
179
	/**
180
	 * 删除实体集合
181
	 * 2018-05-17
182
	 * @author hjf
183
	 * @param entityList 实体集合
184
	 * @return 
185
	 */
186
	public <T> void deleteEntities(Collection<T> entityList) {
187
		commonDao.deleteEntities(entityList);
188
	}
189
190
	/**
191
	 * 更新实体对象 
192
	 * 2018-05-17
193
	 * @author hjf
194
	 * @param entity 要更新的实体
195
	 * @return 
196
	 */
197
	public <T> void updateEntity(T entity) {
198
		commonDao.updateEntity(entity);
199
200
	}
201
202
	/**
203
	 * 查找全部实体 
204
	 * 2018-05-17
205
	 * @author hjf
206
	 * @param clazz 要查找的实体类
207
	 * @return 全部实体列表
208
	 */
209
	public <T> List<T> findAll(final Class<T> clazz) {
210
		return commonDao.findAll(clazz);
211
	}
212
	
213
	/**
214
	 * Hql通过SQL语句获取实体列表 
215
	 * 2018-05-17
216
	 * @author hjf
217
	 * @param sql 查询语句
218
	 * @return 实体列表
219
	 */
220
	public <T> List<T> findListbySql(String sql) {
221
		return commonDao.findListbySql(sql);
222
	}
223
	
224
	/********************jdbc模块************************************/
225
	
226
	/**
227
	 * jdbc  查找实体列表
228
	 * 2018-05-17
229
	 * @author hjf
230
	 * @param sql 查询语句
231
	 * @param clazz 实体类型
232
	 * @param param 参数
233
	 * @return 实体列表
234
	 */
235
	public <T> List<T> findListByJdbc(String sql,Class<T> clazz, Object... param) {
236
		return commonDao.findListByJdbc(sql,  clazz, param);
237
	}
238
	/**
239
	 * jdbc 查找单一实体
240
	 * 2018-05-17
241
	 * @author hjf
242
	 * @param sql 查询语句
243
	 * @param clazz 返回的实体类型
244
	 * @param param 参数列表
245
	 * @return 实体对象
246
	 */
247
	public <T> T findOneByJdbc(String sql,Class<T> clazz, Object... param) {
248
		return commonDao.findOneByJdbc(sql, clazz, param);
249
	}
250
	
251
	/**
252
	 * 执行SQL语句 
253
	 * 2018-05-17
254
	 * @author hjf
255
	 * @param sql 执行语句
256
	 * @param param 参数列表
257
	 * @return 受影响行数
258
	 */
259
	public Integer executeSqlByJdbc(String sql, List<Object> param) {
260
		return commonDao.executeSqlByJdbc(sql, param);
261
	}
262
263
	/**
264
	 * jdbc jdbc 执行SQL 
265
	 * 2018-05-17
266
	 * @author hjf
267
	 * @param sql 执行语句
268
	 * @param param 参数列表
269
	 * @return 受影响行数
270
	 */
271
	public Integer executeSqlByJdbc(String sql, Object... param) {
272
		return commonDao.executeSqlByJdbc(sql, param);
273
	}
274
	
275
	/**
276
	 * jdbc 执行存储过程
277
	 * 2018-05-17
278
	 * @author hjf
279
	 * @param procedureSql 执行语句
280
	 * @param param 参数列表
281
	 * @return 实体列表
282
	 */
283
	public <T> List<T> executeProcedure(String procedureSql,Object... param) {
284
		return this.commonDao.executeProcedure(procedureSql, param);
285
	}
286
}

7、Redis 的使用

这里面我们为了更好的加快数据的读取,对于像后台管理公共此类的数据进行了缓存处理,定期的更新这个缓存。而缓存选取的是Redis,这边不做简要的介绍,后面的文章再做系统的介绍。
以下是缓存操作的服务实现类RedisServiceImpl源码如下:

1
/***
2
 * redis 缓存操作接口
3
 * @author hjf
4
 * @version v-test 测试版本,仅供自己练习使用,未做任何优化封装处理
5
 * 2018-05-19
6
 */
7
@Service("redisServiceImpl")
8
public class RedisServiceImpl implements IRedisService {
9
10
    @Resource
11
    private StringRedisTemplate stringRedisTemplate;
12
    @Resource
13
    private RedisTemplate<String,Object> redisTemplate;
14
    
15
    
16
    /**
17
    *  删除key和value
18
    */
19
    public void delete(String key){
20
    	stringRedisTemplate.delete(key);
21
    }
22
23
    /**
24
    *  根据key获取value
25
    */
26
    public String get(String key){
27
        String value = stringRedisTemplate.opsForValue().get(key);
28
        return value;
29
    }
30
31
    /**
32
    *  将key和value存入redis,并设置有效时间,单位:天
33
    */
34
    public void set(String key, String value, long timeout){
35
    	stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.DAYS);
36
    }
37
38
    /**
39
    *  将key和value存入redis
40
    */
41
    public void set(String key, String value){
42
    	stringRedisTemplate.opsForValue().set(key, value);
43
    }
44
45
    /**
46
    *  从redis中获取map
47
    */
48
    public Map<String, Object> getMap(String key){
49
        HashOperations<String, String, Object>  hash = stringRedisTemplate.opsForHash();
50
        Map<String,Object> map = hash.entries(key);
51
        return map;
52
    }
53
54
    /**
55
    *  将map存入redis,并设置时效
56
    */
57
    public void set(String key, Map<? extends String, ? extends Object> map, long timeout){
58
    	stringRedisTemplate.opsForHash().putAll(key, map);
59
    	stringRedisTemplate.expire(key, timeout, TimeUnit.DAYS);
60
    }
61
    
62
    /**
63
     * 
64
     * 此方法将ArrayList集合直接存储为一个字符串
65
     * @param key
66
     *            存储的名字
67
     * @param list
68
     *            要存储的集合对象
69
     * @param activeTime
70
     *            该对象的有效时间,单位为秒
71
     */
72
    public <T> boolean setList(String key, List<T> list,Integer activeTime) {
73
        if (list != null && key != null && key != "") {
74
        	//首先移除原先缓存
75
        	redisTemplate.delete(key);
76
        	for (T item : list) {
77
        		redisTemplate.opsForList().leftPush(key, item);
78
			}
79
        	return true;
80
        }
81
        return false;
82
    }
83
84
    /**
85
     * 此方法将会把存在redis中的数据取出来,并封装成相应的Arraylist集合
86
     * @param key
87
     *            Key值
88
     * @return List
89
     */
90
    public List<Object> getList(String key) {
91
    	 if (key != null && key != "" ) {
92
    		 List<Object> list = redisTemplate.opsForList().range(key, 0, -1);  //获取缓存中所有的元素
93
             return list;
94
         }
95
         return null;
96
    }
97
}

8、Druid 监控配置

Druid 作为一款非常优秀的开源连接池组件(阿里出品,必属~~),它给我们提供了不只是对于连接池的特性,还能够帮助我们进行系统核心内容的监控,一举两得,何乐而不为呢。下面我们简要了解下吧:

  1. 连接池。提供并帮助我们进行主流数据库的连接池管理
  2. 数据源信息的读取和监控
  3. SQL情况执行监控。帮助我们分析数据库的访问性能,让我们更好的进行SQL的优化,而且还能进行防注入配置
  4. 数据库加密。公私钥的配置方式方便我们加密我们的数据库访问信息
  5. SQL执行日志。内置多种LogFilter可以帮助我们进行日志的处理
  6. 灵活、开源、可扩展性强!(这个就不用多说了~)

在上面的配置文件中我已经配置了启用内置的监控,那么要怎么使用呢?
很简单,只要访问他的默认路径即可,路径为:/system/druid/index,直接访问就可以看到如以下的默认界面
在这里插入图片描述

9、结果展示

好了,让我们来看下最终首页呈现的效果吧
在这里插入图片描述

10、THE END

好了整个Demo的核心就是这些了,如果有小伙伴对于一些理论知识还不是很了解的话,可以关注我的其他文章,有主要内容的详细介绍。

如果有写的不好的或者是有问题的地方还希望您能与我联系,关注网站http://missxhh.com,获得更多有关于我的信息吧!

谢谢阅读,您的关注就是对我最大的动力!!!

文章作者: 黄建峰
文章链接: http://missxhh.com/posts/6c13c125/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 黄建峰

评论