Java开发进销存管理系统(二)

四、底层架构设计

在进行进销存系统的设计和编码之前,首先设计一个自己的底层框架,这个底层框架在之后可以作为其它具体项目开发的一个基础,从而不必每次开发项目时,都去做很多重复的工作。这个底层框架主要包括一个开发的规范,以及一些通用的工具类等,更重要的是分类别引入各个框架,如Spring、Hibernate、各个配置文件等。同时,如果以后在开发中,增加的一些新功能,还可以往这个底层中添加,不断的去完善。

1. 规范

在进行框架设计之前,为了使软件开发过程顺畅、提高代码的可靠性,可读性和可维护性等,首先需要确定的就是开发规范了,俗话说,没有规矩不成方圆,软件开发亦是如此。下面列出一些简单的需要遵守的规范。

1.1 基础规范

首先需要遵守的是一些基础规范。一般来说,公司会将域名作为所有命名的一个基础,比如文件名、包名等等。因此我申请了一个域名[www.lyyzoo.com]作为个人域名。然后将D:/lyyzoo-repo作为开发的根目录,即个人代码仓库,以后所有的项目都会建到这个目录下。所有的项目开发使用maven来管理项目,因此目录结构是标准的maven规范目录。

maven约定的目录结构:

1.2 代码规范

① 命名  

  • 所有的命名需要见名之意,尽量保证通过变量名得知变量的含义,需要注释的地方尽量添加注释。
  • 包命名全小写,通过域名倒写+模块的形式,如:com.lyyzoo.service
  • 类命名采用Pascal名法,大写字母开头,每个单词首字母大写。
  • 方法名采用Camel命名法,小写字母开头,每个单词首字母小写;getter和setter使用Lombok自动生成,只需添加@Data注解即可。
  • 变量名采用Camel命名法,小写字母开头,每个单词首字母大写。变量名不宜过长,可采用首字母缩写的形式,但要见名之意。
  • 常量名全大写,每个单词之间使用”_”分隔。

② 分层

项目以功能模块划分,不同项目建立不同的工程,使用maven的依赖进行管理。包的基本分层有controller(控制层)、service(业务层)、dao(数据访问层)、entity(模型层)。

2. 架构设计

2.1 模块结构

整个项目的底层着重是一些通用的、基础的东西,整合到一起,以便于以后重用。首先,创建一个名为lyyzoo的maven工程,lyyzoo将作为底层的根目录。lyyzoo下有两个主要的子模块,分别为lyyzoo-base和lyyzoo-starter,lyyzoo-base是基础模块,用于一些简单的Java及JavaEE程序;lyyzoo-starter则是JavaEE相关,会依赖于lyyzoo-base,同时引入了Spring、Hibernate等第三方框架。然后在各个模块中添加具体的子模块。以后开发中需要用到哪个模块,在依赖中添加那个模块即可。

底层模块结构图:

以下是各个POM之间的关系:

① lyyzoo > pom.xml

② lyyzoo-base > pom.xml

③ lyyzoo-starter > pom.xml

2.2 依赖管理

结构建好后,就需要进行一些详细的依赖配置工作了,lyyzoo是所有模块的父类,所以在lyyzoo中需要添加公用的属性、依赖管理、maven插件等。

首先将所有的版本号提出来,放到<properties></properties>里,这样一旦需要切换到另一个版本时,就可以只改个版本号就达到目的了。其中列出了一些属性如下:包括底层的版本、Java版本、Spring、Hibernate的版本等等。

1 <properties>
2   <!-- Global -->
3   <lyyzoo.version>1.0-SNAPSHOT</lyyzoo.version>
4   <java.version>1.8</java.version>
5   <maven.compiler.source>${java.version}</maven.compiler.source>
6   <maven.compiler.target>${java.version}</maven.compiler.target>
7   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
8   <!-- lombok -->
9   <lombok.version>1.16.14</lombok.version>
10   <!-- log -->
11   <slf4j.version>1.7.7</slf4j.version>
12   <logback.version>1.1.3</logback.version>
13   <!-- jdbc -->
14   <mysql.version>5.1.38</mysql.version>
15   <!-- http://mvnrepository.com/artifact/com.mchange/c3p0/ -->
16   <c3p0.version>0.9.5.2</c3p0.version>
17   <!-- test -->
18   <junit.version>4.12</junit.version>
19   <!-- servlet -->
20   <servlet.version>3.1.0</servlet.version>
21   <!-- spring -->
22   <spring.version>4.2.6.RELEASE</spring.version>
23   <aspectjrt.version>1.7.3</aspectjrt.version>
24   <aspectjweaver.version>1.7.3</aspectjweaver.version>
25   <!-- hibernate -->
26   <hibernate.version>5.0.1.Final</hibernate.version>
27   <hibernate.jpa.version>1.0.0.Final</hibernate.jpa.version>
28 </properties>

接着,引入依赖管理,在lyyzoo中引入其它项目将会用到的所有三方jar包的依赖,所有的依赖都添加到<dependencyManagement><dependencies></dependencies></dependencyManagement>中,这样就可以方便的管理所有的jar包了。下面列出引入的一部分jar包,其它的可参考源码。

① 首先需要引入lyyzoo下的其它模块,如lyyzoo-base-core、lyyzoo-starter-base等模块。

1 <!-- lyyzoo -->
2 <dependency>
3   <groupId>com.lyyzoo</groupId>
4   <artifactId>lyyzoo-base-core</artifactId>
5   <version>${lyyzoo.version}</version>
6 </dependency>
7 <dependency>
8   <groupId>com.lyyzoo</groupId>
9   <artifactId>lyyzoo-base-data</artifactId>
10   <version>${lyyzoo.version}</version>
11 </dependency>
12 <dependency>
13   <groupId>com.lyyzoo</groupId>
14   <artifactId>lyyzoo-starter-base</artifactId>
15   <version>${lyyzoo.version}</version>
16 </dependency>
17 <dependency>
18   <groupId>com.lyyzoo</groupId>
19   <artifactId>lyyzoo-starter-jpa</artifactId>
20   <version>${lyyzoo.version}</version>
21 </dependency>

② JDBC相关,相关jar包有c3p0,用于作数据库连接池;mysql驱动包;dbutils,对JDBC进行了简单的封装,使用起来简单方便。

1 <!-- jdbc -->
2 <dependency>
3   <groupId>com.mchange</groupId>
4   <artifactId>c3p0</artifactId>
5   <version>${c3p0.version}</version>
6 </dependency>
7 <dependency>
8   <groupId>mysql</groupId>
9   <artifactId>mysql-connector-java</artifactId>
10   <version>${mysql.version}</version>
11 </dependency>
12 <dependency>
13   <groupId>commons-dbutils</groupId>
14   <artifactId>commons-dbutils</artifactId>
15   <version>1.5</version>
16 </dependency>

③ 日志相关:

1 <!-- log -->
2 <dependency>
3   <groupId>org.slf4j</groupId>
4   <artifactId>slf4j-api</artifactId>
5   <version>${slf4j.version}</version>
6 </dependency>
7 <dependency>
8   <groupId>ch.qos.logback</groupId>
9   <artifactId>logback-classic</artifactId>
10   <version>${logback.version}</version>
11 </dependency>
12 <!-- slf4j -->
13 <dependency>
14   <groupId>org.slf4j</groupId>
15   <artifactId>log4j-over-slf4j</artifactId>
16   <version>${slf4j.version}</version>
17 </dependency>

④ spring相关,包括了spring aop、spring mvc等。

1 <!-- springframework -->
2 <dependency>
3   <groupId>org.springframework</groupId>
4   <artifactId>spring-aop</artifactId>
5   <version>${spring.version}</version>
6 </dependency>
7 <dependency>
8   <groupId>org.springframework</groupId>
9   <artifactId>spring-aspects</artifactId>
10   <version>${spring.version}</version>
11 </dependency>
12 <dependency>
13   <groupId>org.springframework</groupId>
14   <artifactId>spring-beans</artifactId>
15   <version>${spring.version}</version>
16 </dependency>
17 <dependency>
18   <groupId>org.springframework</groupId>
19   <artifactId>spring-context</artifactId>
20   <version>${spring.version}</version>
21 </dependency>
22 <dependency>
23   <groupId>org.springframework</groupId>
24   <artifactId>spring-context-support</artifactId>
25   <version>${spring.version}</version>
26 </dependency>
27 <dependency>
28   <groupId>org.springframework</groupId>
29   <artifactId>spring-core</artifactId>
30   <version>${spring.version}</version>
31 </dependency>
32 <dependency>
33   <groupId>org.springframework</groupId>
34   <artifactId>spring-jdbc</artifactId>
35   <version>${spring.version}</version>
36 </dependency>
37 <dependency>
38   <groupId>org.springframework</groupId>
39   <artifactId>spring-jms</artifactId>
40   <version>${spring.version}</version>
41 </dependency>
42 <dependency>
43   <groupId>org.springframework</groupId>
44   <artifactId>spring-orm</artifactId>
45   <version>${spring.version}</version>
46 </dependency>
47 <dependency>
48   <groupId>org.springframework</groupId>
49   <artifactId>spring-tx</artifactId>
50   <version>${spring.version}</version>
51 </dependency>
52 <dependency>
53   <groupId>org.springframework</groupId>
54   <artifactId>spring-web</artifactId>
55   <version>${spring.version}</version>
56 </dependency>
57 <dependency>
58   <groupId>org.springframework</groupId>
59   <artifactId>spring-webmvc</artifactId>
60   <version>${spring.version}</version>
61 </dependency>

⑤ hibernate相关:

1 <dependency>
2   <groupId>org.hibernate</groupId>
3   <artifactId>hibernate-c3p0</artifactId>
4   <version>${hibernate.version}</version>
5 </dependency>
6 <dependency>
7   <groupId>org.hibernate.common</groupId>
8   <artifactId>hibernate-commons-annotations</artifactId>
9   <version>${hibernate.version}</version>
10 </dependency>
11 <dependency>
12   <groupId>org.hibernate</groupId>
13   <artifactId>hibernate-core</artifactId>
14   <version>${hibernate.version}</version>
15 </dependency>
16 <dependency>
17   <groupId>org.hibernate</groupId>
18   <artifactId>hibernate-entitymanager</artifactId>
19   <version>${hibernate.version}</version>
20 </dependency>

所有的依赖添加好后,就需要为各个子模块添加具体的依赖了,根据每个子模块的功能,添加相关的依赖,而不是将所有的依赖一次性加入。这样我们就可以根据自己开发的项目的需要,添加模块依赖,而不是一次性加入所有jar包,避免冗余,增大项目的体积。下面以lyyzoo-base-data和lyyzoo-starter-jpa为例说明。

lyyzoo-base-data模块是基础数据相关,主要与数据库打交道,那么就需要引入mysql驱动、数据库连接池c3p0等,pom.xml如下:

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     <modelVersion>4.0.0</modelVersion>
4     <parent>
5         <groupId>com.lyyzoo</groupId>
6         <artifactId>lyyzoo-base</artifactId>
7         <version>1.0-SNAPSHOT</version>
8     </parent>
9     <artifactId>lyyzoo-base-data</artifactId>
10     <name>${project.artifactId}</name>
11     <packaging>jar</packaging>
12 
13     <dependencies>
14         <!-- dbutils -->
15         <dependency>
16             <groupId>commons-dbutils</groupId>
17             <artifactId>commons-dbutils</artifactId>
18         </dependency>
19         <!-- jdbc -->
20         <dependency>
21             <groupId>mysql</groupId>
22             <artifactId>mysql-connector-java</artifactId>
23         </dependency>
24         <dependency>
25             <groupId>com.mchange</groupId>
26             <artifactId>c3p0</artifactId>
27         </dependency>
28     <!-- test -->
29         <dependency>
30             <groupId>com.lyyzoo</groupId>
31             <artifactId>lyyzoo-base-test</artifactId>
32             <scope>test</scope>
33         </dependency>
34     </dependencies>
35 </project>

lyyzoo-starter-jpa是Java持久化相关,所以主要引入hibernate相关的依赖,同时,starter-jpa会依赖base-data及starter-base,pom.xml如下:

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     <modelVersion>4.0.0</modelVersion>
4     <parent>
5         <groupId>com.lyyzoo</groupId>
6         <artifactId>lyyzoo-starter</artifactId>
7         <version>1.0-SNAPSHOT</version>
8     </parent>
9     <artifactId>lyyzoo-starter-jpa</artifactId>
10     <name>${project.artifactId}</name>
11     <packaging>jar</packaging>
12 
13     <dependencies>
14         <dependency>
15             <groupId>com.lyyzoo</groupId>
16             <artifactId>lyyzoo-base-data</artifactId>
17         </dependency>
18         <dependency>
19             <groupId>com.lyyzoo</groupId>
20             <artifactId>lyyzoo-starter-base</artifactId>
21         </dependency>
22         <dependency>
23             <groupId>org.hibernate</groupId>
24             <artifactId>hibernate-c3p0</artifactId>
25         </dependency>
26         <dependency>
27             <groupId>org.hibernate.common</groupId>
28             <artifactId>hibernate-commons-annotations</artifactId>
29         </dependency>
30         <dependency>
31             <groupId>org.hibernate</groupId>
32             <artifactId>hibernate-core</artifactId>
33         </dependency>
34         <dependency>
35             <groupId>org.hibernate</groupId>
36             <artifactId>hibernate-ehcache</artifactId>
37         </dependency>
38         <dependency>
39             <groupId>org.hibernate.javax.persistence</groupId>
40             <artifactId>hibernate-jpa-2.1-api</artifactId>
41         </dependency>
42         <dependency>
43             <groupId>org.hibernate</groupId>
44             <artifactId>hibernate-validator</artifactId>
45         </dependency>
46         <dependency>
47             <groupId>com.lyyzoo</groupId>
48             <artifactId>lyyzoo-starter-test</artifactId>
49             <scope>test</scope>
50         </dependency>
51     </dependencies>
52 </project>

2.3 类结构

有了前面的基础之后,接下来进行重点的类结构设计。底层需要做的最重要的工作就是将一些通用的类抽象出来,以便于以后重用,从而提高开发效率。例如返回结果和分页类的封装、通用的工具类、JDBC相关的操作等。

说明一下,整个底层很大一部分是从之前实习的公司(这个就不说了)直接拿过来的,有些则更改了。相信我拿取的这部分代码并不会涉及机密问题,不用于商业用途,仅仅只是学习,应该没多大问题。

(1) lyyzoo-base-core

lyyzoo-base-core 目录结构:

lyyzoo-base-core是基础核心,封装了返回结果和加入了一些常用的工具类。

com.lyyzoo.bean包下封装了BaseBean和Result,BaseBean是Bean类的一个基础类,实现了序列化,重写了toString()方法,如下:

1 package com.lyyzoo.bean;
2 
3 import org.apache.commons.lang3.builder.ToStringBuilder;
4 import org.apache.commons.lang3.builder.ToStringStyle;
5 
6 import java.io.Serializable;
7 
8 /**
9  * BaseBean 实现序列化 <p>
10  *
11  * @author bojiangzhou
12  * @date 2017-03-27
13  */
14 public abstract class BaseBean implements Serializable {
15 
16     /**
17      * ToStringBuilder – 用于辅助实现Object.toString()方法<p>
18      */
19     public String toString() {
20         return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
21     }
22 
23 }

Result则封装了返回的结果,这里主要与ExtJs相对应,ExtJs进行ajax请求时,返回success=true,会进入success()方法;返回success=false,会进入failure()方法。同时,封装了返回消息、标识、错误信息等,便于前端拿到相应数据。

1 package com.lyyzoo.bean;
2 
3 import lombok.Data;
4 
5 import java.util.Map;
6 
7 /**
8  * 封装返回结果<p>
9  *
10  * @author bojiangzhou
11  * @date 2017-03-27
12  */
13 @Data
14 public class Result extends BaseBean {
15     private static final long serialVersionUID = 1L;
16 
17     /**
18      * 成功标志
19      */
20     public boolean success;
21     /**
22      * 返回标示
23      */
24     public Integer code;
25     /**
26      * 相关消息
27      */
28     public String msg;
29     /**
30      * 相关数据
31      */
32     public Object data;
33     /**
34      * 错误详细
35      */
36     public Map<String, Object> errors;
37 
38     public Result() {
39 
40     }
41 
42     public Result(boolean success) {
43         this.success = success;
44     }
45 
46     public Result(boolean success, Integer code, Object data, String msg) {
47         this(success);
48         this.code = code;
49         this.data = data;
50         this.msg = msg;
51     }
52 
53     public Result(Integer code, Map<String, Object> errors, String msg) {
54         this.success = false;
55         this.code = code;
56         this.errors = errors;
57         this.msg = msg;
58     }
59 
60     public boolean isSuccess() {
61         return this.success;
62     }
63 
64     public boolean hasErrors() {
65         if (this.errors != null && this.errors.size() > 0) {
66             return true;
67         }
68         return false;
69     }
70 }

其它的主要是一些工具类,例如Arrays继承了org.apache.commons.lang3.ArrayUtils,使得Arrays具有了丰富的操作集合的工具。再如Dates,Dates里封装了大量的对日期操作的方法,比如格式化日期、获取某个日期当天的开始时间和结束时间等。

(2) lyyzoo-starter-base

lyyzoo-starter-base 目录结构:

lyyzoo-starter-base是web应用程序的一个基础,主要封装了基础实体类以及spring-base和日志的配置。实体的顶层是AbstractEntity<ID extends Serializable>,AbstractEntity继承BaseBean。AbstractEntity重写了equals和hashCode方法,主要做的处理是,如果两个实体的id相同也算这两个对象为同一个对象。代码如下:

1 package com.lyyzoo.data.entity;
2 
3 import com.lyyzoo.bean.BaseBean;
4 
5 import java.io.Serializable;
6 
7 /**
8  * 抽象实体类 重写equals和hashCode方法
9  *
10  * @author bojiangzhou
11  * @date 2017-03-28
12  */
13 @SuppressWarnings("serial")
14 public abstract class AbstractEntity<ID extends Serializable> extends BaseBean implements Serializable {
15 
16     public abstract ID getId();
17 
18     @Override
19     public boolean equals(Object obj) {
20 
21         if (null == obj) {
22             return false;
23         }
24         if (this == obj) {
25             return true;
26         }
27         if (!getClass().equals(obj.getClass())) {
28             return false;
29         }
30 
31         AbstractEntity<?> that = (AbstractEntity<?>) obj;
32 
33         return null == this.getId() ? false : this.getId().equals(that.getId());
34     }
35 
36     @Override
37     public int hashCode() {
38         int hashCode = 17;
39 
40         hashCode += null == getId() ? 0 : getId().hashCode() * 31;
41 
42         return hashCode;
43     }
44 
45 }

BaseEntity则继承AbstractEntity,BaseEntity作为其它实体的父类存在,BaseEntity定义了主键ID的生成策略。代码如下:

1 package com.lyyzoo.data.entity;
2 
3 import lombok.Data;
4 
5 import javax.persistence.GeneratedValue;
6 import javax.persistence.GenerationType;
7 import javax.persistence.Id;
8 import javax.persistence.MappedSuperclass;
9 
10 /**
11  * 统一定义id的entity基类.
12  * <p/>
13  * 抽象实体基类,提供统一的ID,和相关的基本功能
14  * <p/>
15  */
16 @Data
17 @MappedSuperclass
18 @SuppressWarnings("serial")
19 public abstract class BaseEntity extends AbstractEntity<Long> {
20 
21     /**
22      * id 字段
23      */
24     @Id
25     protected Long id;
26 
27     @Id
28     @GeneratedValue(strategy = GenerationType.IDENTITY)
29     public Long getId() {
30         return this.id;
31     }
32 
33     public void setId(Long id) {
34         this.id = id;
35     }
36 }

spring-base.xml是基础配置,主要配置了扫描系统的配置文件、注解等。

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3        xmlns="http://www.springframework.org/schema/beans"
4        xmlns:beans="http://www.springframework.org/schema/beans"
5        xmlns:context="http://www.springframework.org/schema/context"
6        xmlns:aop="http://www.springframework.org/schema/aop"
7        xmlns:tx="http://www.springframework.org/schema/tx"
8        xmlns:util="http://www.springframework.org/schema/util"
9        xmlns:mvc="http://www.springframework.org/schema/mvc"
10        xmlns:jee="http://www.springframework.org/schema/jee"
11        xmlns:jdbc="http://www.springframework.org/schema/jdbc"
12        xmlns:tool="http://www.springframework.org/schema/tool"
13        xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
14        xsi:schemaLocation="
15     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
16     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
17     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
18     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
19     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
20     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
21     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
22     http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
23     http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd
24     http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd"
25 >
26 
27     <description>Spring Base Config</description>
28 
29     <!-- 加载config.properties -->
30     <context:property-placeholder location="classpath*:/config/*.properties" file-encoding="UTF-8" />
31 
32     <!-- 使用annotation 自动注册bean, 并保证@Required、@Autowired的属性被注入 -->
33     <context:component-scan base-package="com.lyyzoo">
34         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
35         <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
36     </context:component-scan>
37 
38     <!-- 支持上传文件 -->
39     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>
40 
41 </beans>
(3) lyyzoo-starter-jpa

lyyzoo-starter-jpa 目录结构:

lyyzoo-starter-jpa集成了持久化相关的操作,配置等。

首先需要做持久化相关的配置(spring-base-jpa.xml),如数据源、SessionFactory、事务管理等。数据源使用c3p0,数据源相关配置如数据库驱动、地址等写到到配置文件中。配置Hibernate SessionFactory的同时,增加了JdbcTemplate。事务管理器使用Hibernate的事务管理。总的配置如下:

1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3     xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:beans="http://www.springframework.org/schema/beans"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:aop="http://www.springframework.org/schema/aop"
 7     xmlns:context="http://www.springframework.org/schema/context"
 8     xmlns:mvc="http://www.springframework.org/schema/mvc"
 9     xmlns:util="http://www.springframework.org/schema/util"
10     xmlns:jee="http://www.springframework.org/schema/jee"
11     xmlns:jdbc="http://www.springframework.org/schema/jdbc"
12     xmlns:tool="http://www.springframework.org/schema/tool"
13     xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
14     xsi:schemaLocation="
15     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 16     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
 17     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
 18     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
 19     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
 20     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
 21     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
 22     http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
 23     http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd
 24     http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd"
25     >
26 
27     <description>Spring Jpa</description>
28 
29     <!-- 使用C3P0 -->
30     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
31         <property name="driverClass" value="${jdbc.driver}"/>
32         <property name="jdbcUrl" value="${jdbc.url}"/>
33         <property name="user" value="${jdbc.username}"/>
34         <property name="password" value="${jdbc.password}"/>
35 
36         <!-- default: 3 -->
37         <!-- 初始化时获取三个连接,取值应在minPoolSize与maxPoolSize之间。-->
38         <property name="initialPoolSize" value="${c3p0.initialPoolSize:5}"/>
39 
40         <!-- default: 3 -->
41         <!-- 连接池保留最小连接数-->
42         <property name="minPoolSize" value="${c3p0.minPoolSize:5}"/>
43 
44         <!-- default: 15 -->
45         <!-- 连接池保留最大连接数。-->
46         <property name="maxPoolSize" value="${c3p0.maxPoolSize:15}"/>
47 
48         <!-- default: 0(秒) = 永不丢弃-->
49         <!-- 最大空闲时间,600 秒内未使用则连接被丢弃。-->
50         <property name="maxIdleTime" value="${c3p0.maxIdleTime:600}"/>
51     </bean>
52 
53     <!-- sessionFactory -->
54     <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
 55         <property name="dataSource" ref="dataSource" />
56         <property name="hibernateProperties" >
57             <props>
58                 <prop key="dialect">${hibernate.dialect}</prop>
59                 <prop key="show_sql">${hibernate.show.sql}</prop>
60                 <prop key="hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
61             </props>
62         </property>
63         <!-- 扫描hibernate注解实体 -->
64         <property name="packagesToScan">
65             <list>
66                 <value>com.lyyzoo.*.entity</value>
67             </list>
68         </property>
69     </bean>
70 
71     <!-- jdbcTemplate -->
72     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
73         <property name="dataSource" ref="dataSource"/>
74     </bean>
75     <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
 76         <constructor-arg ref="dataSource"/>
77     </bean>
78     <bean id="jdbcTemplateSupport" class="com.lyyzoo.data.jdbc.JdbcTemplateSupport">
79         <property name="dataSource" ref="dataSource"/>
80         <property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"/>
 81     </bean>
82 
83     <!-- 事务管理器 -->
84     <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
 85         <property name="sessionFactory" ref="sessionFactory" />
86     </bean>
87 
88     <!-- 事务通知属性 -->
89     <tx:advice id="transactionManagerAdvice" transaction-manager="transactionManager">
 90         <tx:attributes>
91             <tx:method name="get*"        read-only="true"         />
92             <tx:method name="load*"        read-only="true"        />
93             <tx:method name="find*"        read-only="true"        />
94             <tx:method name="list*"        read-only="true"        />
95             <tx:method name="page*"        read-only="true"        />
96             <tx:method name="query*"    read-only="true"        />
97             <tx:method name="*"            propagation="REQUIRED"    />
98         </tx:attributes>
99     </tx:advice>
100 
101     <!-- AOP 事务 -->
102     <aop:config proxy-target-class="true">
103         <aop:pointcut id="serviceMethod" expression="execution(* com.lyyzoo..*Service.*(..))"/>
104         <aop:advisor pointcut-ref="serviceMethod" advice-ref="transactionManagerAdvice"/>
105     </aop:config>
106 
107     <!-- 扫描注解 -->
108     <context:component-scan base-package="com.lyyzoo" />
109 
110 </beans>

然后在com.lyyzoo.data.domain包下,Page封装了分页相关的属性,如当前页数据、页码、每页大小、总页数等。com.lyyzoo.data.util包下,Sqls封装了操作sql语句的工具,比如根据传入的查询语句,返回查询总数的sql语句。在com.lyyzoo.data.jdbc包下,JdbcTemplateSupport封装了比较复杂的查询,比如根据传入的参数、分页条件等,自动查询数据、总数并封装到Page里返回。com.lyyzoo.data.dao包下,SimpleDao封装了基于Hibernate SessionFactory的简单的增删改查操作,如save(),get()等方法。dao包下,BaseDao继承SimpleDao,并代理了JdbcTemplateSupport,使得BaseDao具有SimpleDao和JdbcTemplateSupport的功能,BaseDao则作为其它dao的一个父类存在。最后,在com.lyyzoo.service包下,BaseService代理了BaseDao,进行了进一步的封装,BaseService是其它service类的父类,其它service就可以直接调用save、get、page等内置方法。

(4) lyyzoo-starter-web

lyyzoo-starter-web自然跟web相关,在com.lyyzoo.web包下,BaseController作为controller类的父类,主要封装了返回结果集等信息。还有web相关配置,如视图解析器等内容:

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3     xmlns="http://www.springframework.org/schema/beans"
4     xmlns:beans="http://www.springframework.org/schema/beans"
5     xmlns:tx="http://www.springframework.org/schema/tx"
6     xmlns:aop="http://www.springframework.org/schema/aop"
7     xmlns:context="http://www.springframework.org/schema/context"
8     xmlns:mvc="http://www.springframework.org/schema/mvc"
9     xmlns:task="http://www.springframework.org/schema/task"
10     xmlns:util="http://www.springframework.org/schema/util"
11     xmlns:jee="http://www.springframework.org/schema/jee"
12     xmlns:jdbc="http://www.springframework.org/schema/jdbc"
13     xmlns:tool="http://www.springframework.org/schema/tool"
14     xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
15     xsi:schemaLocation="
16     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
17     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
18     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
19     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
20     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
21     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
22     http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd
23     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
24     http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
25     http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd
26     http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd"
27     >
28 
29     <description>Spring Web</description>
30     
31     <!-- 加载config.properties -->
32     <context:property-placeholder location="classpath*:/config/*.properties" file-encoding="UTF-8" />
33             
34     <!-- 扫描Controller以及ControllerAdvice -->
35     <context:component-scan base-package="com.lyyzoo" use-default-filters="false">
36         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
37         <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
38     </context:component-scan>
39 
40     <!-- 静态资源映射 -->
41     <mvc:resources location="/static/" mapping="/static/**"/>
42 
43     <!-- 容器默认的DefaultServletHandler处理 所有静态内容与无RequestMapping处理的URL-->    
44     <mvc:default-servlet-handler />
45 
46     <!-- 支持@Controller注解 -->
47     <mvc:annotation-driven />
48 
49     <!-- 视图解析器 -->
50     <bean id="jspViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
51         <property name="prefix" value="/WEB-INF/view"/>
52         <property name="suffix" value=".jsp"/>
53     </bean>
54     
55 </beans>
(5) 类结构图

类结构图参考《底层类结构.vsd》

原文发布于微信公众号 - Java团长(javatuanzhang)

原文发表时间:2018-11-26

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Play & Scala 技术分享

Java基础 - 常用路径操作总结

30870
来自专栏JAVA烂猪皮

JAVA多线程与并发学习总结

使用高速缓存来作为内存与处理器之间的缓冲,将运算需要用到的数据复制到缓存中,让计算能快速进行;当运算结束后再从缓存同步回内存之中,这样处理器就无需等待缓慢的内存...

8910
来自专栏Felix的技术分享

《一个操作系统的实现》笔记(1)--NASM汇编语法和环境搭建

66430
来自专栏菩提树下的杨过

struts2使用Convention Plugin在weblogic上以war包部署时,找不到Action的解决办法

环境: struts 2.3.16.3 + Convention Plugin 2.3.16.3 实现零配置 现象:以文件夹方式部署在weblogic(10.3...

248100
来自专栏爱撒谎的男孩

struts核心配置文件详解(result配置)

<package name="Login" extends="struts-default" namespace="/"> ​ <action name...

36650
来自专栏开发与安全

linux网络编程之System V 消息队列(二):消息队列实现回射客户/服务器和 msgsnd、msgrcv 函数

一、msgsnd 和 msgrcv 函数   #include <sys/types.h>   #include <sys/ipc.h>   #inclu...

23800
来自专栏java、Spring、技术分享

Netty 新连接的接入

本文通过源码分析Netty是如何一步步的将接收客户端的新连接,然后将连跟NioEventLoop绑定,并注册相应的Read事件。

23220
来自专栏xingoo, 一个梦想做发明家的程序员

跟着ZooKeeper学Java——CountDownLatch和Join的使用

在阅读ZooKeeper的源码时,看到这么一个片段,在单机模式启动的时候,会调用下面的方法,根据zoo.cfg的配置启动单机版本的服务器: public voi...

36740
来自专栏PHP在线

PHP预定义变量数组种类概览

PHP预定义变量数组1、$_SERVER $_SERVER超级全局变量包含由web服务器创建的信息,它提供了服务器和客户配置及当前请求环境的有关信息。根据服务器...

36490
来自专栏吴伟祥

spring为何要注入接口,而注入接口的实现类就会报错

  首先说明,注入的对象确实为实现类的对象。(并不是实现类的代理对象,注入并不涉及代理)

23710

扫码关注云+社区

领取腾讯云代金券