Spring-SpringMVC-Hibernate在IntelliJ与Maven的环境下搭建

http://mark-yang.github.io/blog/2015/04/24/spring-springmvc-hibernate/

本篇主要介绍的是JavaEE中的框架SpringMVC,在以前上JavaEE课程时,课程项目里使用的是比较“古老”的SSH(Struts2+Spring+Hibernate)框架,最近受某小朋友的影响着手了解SpringMVC,一种更轻量级,更方便使用的框架。老规矩,附Wikipedia链接——Spring,其中Model-view-controller framework部分的介绍就是我们常说的SpringMVC

受以前项目的影响,感觉框架的合理使用可以省去不少的麻烦。所以此次介绍的是另一种多框架的混合使用,即,Spring + SpringMVC + Hibernate框架在InteliJMaven的环境下的搭建,并采用注释的写法。后续还会有在此框架的基框之上的demo,敬请期待。


搭建环境

操作系统:Mac OSX Yosemite Version 10.10.3

集成开发环境(IDE):IntelliJ IDEA 14.1

本地服务器:Tomcat 8.0.21

Maven版本:Maven3 3.0.5


目录

一、SpringMVC框架的使用

二、SpringMVC与Spring结合

三、Hibernate框架的加入

四、总结


一、SpringMVC框架的使用

1.建立工程

首先我们在IntelliJ中建立一个JavaEE Project,选择Maven工程,选择org.apache.marmotta:marmotta-archetype-webapp,然后输入GroupIdArtifactId,这里就不做详细的介绍了。 

2.项目结构

工程建好了之后,如果想先看一下本文所展示的demo的工程目录,用来为后面的步骤过程中路径配置时作为参考,其次还有项目的源码都请戳:structure:https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/structure.png 源码:https://github.com/MarK-YANG/Spring-SpringMVC-Hibernate

3.pom.xml

正如开始的时候介绍的一样,我们使用Maven来管理我们在项目使用到的各种包,而所有包的配置信息都在pom.xml文件中,所以我们首要的工作就是通过pom.xml文件来找并管理到我们想要的包。在pom.xml文件中加入我们所需要的dependenceproperties,具体如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

<properties> <!-- spring版本号 --> <spring.version>4.0.4.RELEASE</spring.version> </properties> <dependencies> <!-- spring核心包 --> <!-- springframe start --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> <!-- springframe end --> <dependency> <groupId>javax.servlet.jsp.jstl</groupId> <artifactId>javax.servlet.jsp.jstl-api</artifactId> <version>1.2.1</version> </dependency> <dependency> <groupId>taglibs</groupId> <artifactId>standard</artifactId> <version>1.1.2</version> </dependency> <dependency> <groupId>tomcat</groupId> <artifactId>servlet-api</artifactId> <version>5.5.23</version> <scope>provided</scope> </dependency> <dependency> <groupId>tomcat</groupId> <artifactId>jsp-api</artifactId> <version>5.5.23</version> <scope>provided</scope> </dependency> <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.1</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-validator</artifactId> <version>5.1.2.Final</version> </dependency> <!-- json数据 --> <dependency> <groupId>org.codehaus.jackson</groupId> <artifactId>jackson-mapper-asl</artifactId> <version>1.9.13</version> </dependency> </dependencies>

然后,简单的介绍一下这些我们导入的包, spring-webmvc是我们SpringMVC框架的核心包,spring-core,spring-web都是其依赖包。

其次,jstltaglibs等包是为了在jsp页面中使用JSTL标签。

然后,jackson-mapper包是使springMVC可以返回json值,json和xml方法是我们常用的两种网络传值方式。在springMVC中仅提供了json的接口,并未提供其实现,所以我们要导入它的实现包json-mapper。

再之,commons-fileupload包是为了文件上传所需要的,在本文中的demo中并未涉及到文件的上传,可以选择不添加。

然后,hibernate-validator是为了正常的使用springMVC中的valid,这是因为springMVC中的valid只提供了接口的实现,如果想使用这个接口,就必须要导入它的实现——hibernate-validator,但这项在本文中也未涉及,可以选择不添加。

4.修改web.xml

springMVC中只有一个核心的Servlet,所以我们要在web.xml中注册这个springMVC的Servlet,web.xml文件如下,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" metadata-complete="true" version="3.0"> <servlet> <servlet-name>spring-dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>spring-dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>

这只是我们配置springMVC的开始,springMVC还有许多其他的配置项,但其他的配置项在另一个文件中,这个配置文件就是默认位置为web.xml同路径下的——<servlet-name>-servlet.xml。如,我的web.xml中配置的是spring-dispatcher,对应的xml文件的名字应为:spring-dispatcher-servlet.xml

5.开始配置spring-dispatcher-servlet.xml

我们在与web.xml同路径下创建spring-dispatcher-servlet.xml如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"> <!-- 扫描controller(controller层注入) --> <context:component-scan base-package="com.mark.java.controller"/> <mvc:annotation-driven /> <!-- 对模型视图添加前后缀 --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/pages/"/> <property name="suffix" value=".jsp"/> </bean> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="defaultEncoding" value="UTF-8"/> <property name="maxUploadSize" value="2000000"/> </bean> <mvc:resources mapping="/static/**" location="/"/> <mvc:default-servlet-handler /> </beans>

简单的解释一下,springMVC中的虚拟路径与处理函数的映射,是通过annotation(注释)来设置的,而这些类都在哪个包下面,就是通过component-scan属性配置的,并设置支持annotation支持。

springMVC的每一个处理函数都会返回一个String类型的变量(有的函数返回值就是 String,有的返回值是一个对象,对象里有一个viewResolver需要的字符串),我们这里设置了一个前缀和后缀,举个例子来说,对于函数返回的这个String,比如是fowafolo,那么需要的文件就是/pages/fowafolo.jsp

multipartResolver是上传文件需要的配置,本文中并未涉及到。

最后是对静态资源的映射,经过这个映射之后,要访问/static/fowafolo.png时,实际访问的就是/resources/fowafolo.png

6.MainController

下面我们开始写我们springMVC中的第一个controller, MainController,这个controller的位置就应该是我们刚才配置的spring-dispatcher-servlet.xmlcomponent-scan配置的路径下,代码如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

@Controller @RequestMapping("/") public class MainController { @RequestMapping("") public String index(){ return "index"; } @RequestMapping("/json") @ResponseBody public Map<String, String> json(){ Map<String, String> result = new HashMap<String, String>(); result.put("MarK", "hello"); result.put("Ken", "Hehe"); result.put("Fowafolo", "fool"); return result; } }

简单的解释一下,这个controller的RequestMapping是"/",index()的RequestMapping也是"/",而方法json的RequestMapping是"/json",也就是说,当访问的URL是”/“时,我们会调用index()方法处理,它返回的字符串是index,再根据我们配置文件中的路径,它指向的就是我们/webapp/pages下的index.jsp,所以别忘了去在这个目当下新建一个index.jsp,给一个简单的例子。

1 2 3 4 5 6 7 8 9 10 11 12

<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title></title> </head> <body> <h1>Hello, Fowafolo</h1> <h2>Fowafolo is a foolish !</h2> </body> </html>

部署工程,我们给这个工程加一个前缀,如/spring,那么我们访问:http://localhost:8080/spring/得到的就是我们新建的index.jsp,如果我们访问http://localhost:8080/spring/json得到的就是我们json的返回值:{"MarK":"hello","Ken":"Hehe","Fowafolo":"fool"}

最后,我们再多说几句,因为我们想在/webapp/pages下管理我们所有jsp,所以/webapp下的index.jsp可以不保留,其次,在部署项目时,不建议勾选此项,手动的在browser中输入url更好。


二、SpringMVC与Spring结合

Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

1. 再次配置web.xml

Spring要在程序调用某个对象的时候,就要首先把这个对象的实例注入进去。Spring自己对实例、程序运行的管理构成了Spring自己的容器,第一步就是要在web.xml中注册初始化这个容器。在此之前我们先在/resources文件夹下,创建子路径META-INF,然后在这个文件夹下,创建我们后面要用到的applicationContext.xml文件,如果用过spring框架的人对这个文件都不会陌生,这是spring的配置文件。最后web.xml文件如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" metadata-complete="true" version="3.0"> <servlet> <servlet-name>spring-dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>spring-dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:/META-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>

2. 配置applicationContext.xml文件

spring4之后,spring配置的bean不是在xml文件中配置了,而是采用固定扫描annotation的类,根据对象的类型或者名字自动加载,但此前提是我们仍然要在配置文件中配置好这些类所在包的路径。最后applicationContext.xml文件如下,

1 2 3 4 5 6 7 8 9 10 11 12 13 14

<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd"> <context:component-scan base-package="com.mark.java.service"/> </beans>

3. 创建一个Service类,UserService.java

Service的创建我们还是比较推荐具体的service实现相应的接口的方式,下面我们写一个服务类,用来获取注册的用户,在包com.mark.java.service下创建接口UserService

1 2 3

public interface UserService { public List<String> getAllUsernames(); }

然后再创建一个UserServiceImpl来实现此接口,

1 2 3 4 5 6 7 8 9 10 11 12

@Service public class UserServiceImpl implements UserService { public List<String> getAllUsernames() { List<String> users = new ArrayList<String>(); users.add("MarK"); users.add("Ken"); users.add("Fowafolo"); return users; } }

注意!!!,我们要对个实现加上注释@Service,这是在告诉spring,我需要你来管理我。

4. 修改MainController

在上一节中,我们通过json来返回一个json对象,现在我们修改这个方法,通过刚刚创建的service来返回用户列表给客户端。

首先,我们得先定义一个全局变量,usrService

1 2

@Autowired private UserService userService;

这里要注意的是Autowire这个annotation,它是为了告诉spring,这个对象没有实例化,需要注入一个UserService的实例,可是问题是,UserSerivce是一个接口,如果不指定就不知道你想用哪个实现类,Spring会首先看自己的容器里有没有一个叫做userService的对象(刚才创建的UserServiceImpl的对象名字就叫做userServiceImpl),如果找不到就在配置文件里配置的路径下面寻找UserService的实现类,找到了就把它的对象拿过来.除此之外刚才Service那个annotation还可以指 定一个value:@Service("userService")。这样一来,对于UserServiceImpl这个类的实例,Spring给它起的名字就不是userServiceImpl了,而是userService,如果某个接口的实现类有多个,就可以使用这种方法来指定用哪个实现类,个人认为,如果每个接口都只有一个实现类,那么这么做确实很方便,但如果有多个实现类并且可能会更换的话,就不如配置文件明了了。

说了半天,最后修改json方法,

1 2 3 4 5

@RequestMapping("/json") @ResponseBody public List<String> json(){ return userService.getAllUsernames(); }

Spring在这里的作用就是把MainController需要的userService引入进来,然后访问http://localhost:8080/spring/json会得到以下结果:

["MarK","Ken","Fawofolo"]


三、Hibernate框架的加入

Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。

1. 导入Hibernate所需要的包

pom.xml中,在properties标签下面定义一个版本,

1 2 3 4

<properties> <spring.version>4.0.4.RELEASE</spring.version> <hibernate.version>4.3.5.Final</hibernate.version> </properties>

然后加入hibernate的核心包,因为要让Spring管理一些对象,还要引入spring-orm的包:

1 2 3 4 5 6 7 8 9 10

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

除此之外,因为我们要用mysql数据库,并使用c3p0连接池,因此需要引入这两个对应的包:

1 2 3 4 5 6 7 8 9 10

<dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.31</version> </dependency>

2. 再次修改web.xml

Hibernate通过SessionFactory来获取Session,我们要在spring的配置文件中配置一个我们所需的SessionFactory,为了便于修改,我们新建一个配置文件,路径与spring的配置文件相同,我们新建一个infrastructure.xml, 最后我们的web.xml文件如下,其他的不做具体的介绍了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" metadata-complete="true" version="3.0"> <servlet> <servlet-name>spring-dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>spring-dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <filter> <filter-name>hibernateFilter</filter-name> <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>hibernateFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- Spring字符集过滤器 --> <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> <!-- 读取spring配置文件 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:/META-INF/applicationContext.xml, classpath:/META-INF/infrastructure.xml </param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>

3. 配置hibernate.properties, infrastructure.xml

infrastructure.xml之前,我们要在/META-INF下新建properties文件夹,在里在新建hibernate.properties文件用来加入我们数据库的参数,hibernate.properties的配置如下,

1 2 3 4 5 6 7 8 9 10

hibernate.dialect=org.hibernate.dialect.MySQLDialect driverClassName=com.mysql.jdbc.Driver validationQuery=SELECT 1 url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8 username=root password=yang hibernate.hbm2ddl.auto=none hibernate.show_sql=true hibernate.format_sql=true

注意以下几点,

driverClassName是你所连数据库的驱动的jar包的名称,这里我用的MySQL,所以是com.mysql.jdbc.Driver

url是连接数据库的url,这里是jdbc:mysql://localhost:3306/本机本地数据库,后面是数据库的名称,为test,然后后面的一串,是JDBC对数据库进行CRUD时的编码,我们采用UTF-8以支持中文。

usernamepassword是本地数据库的用户名和密码。

其他项可无视。infrastructure.xml的配置如下:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

<?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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-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/context http://www.springframework.org/schema/context/spring-context-3.0.xsd "> <context:property-placeholder location="classpath:/META-INF/properties/hibernate.properties" /> <!-- 使用C3P0数据源,MySQL数据库 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <!-- MySQL5 --> <property name="driverClass" value="${driverClassName}"></property> <property name="jdbcUrl" value="${url}"></property> <property name="user" value="${username}"></property> <property name="password" value="${password}"></property> <property name="maxPoolSize" value="40"></property> <property name="minPoolSize" value="1"></property> <property name="initialPoolSize" value="1"></property> <property name="maxIdleTime" value="20"></property> </bean> <!-- session工厂 --> <!-- spring与hibernate整合配置,扫描所有dao --> <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="packagesToScan" value="com.mark.java.entity" /> <property name="hibernateProperties"> <props> <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> <prop key="hibernate.dialect">${hibernate.dialect}</prop> <prop key="hibernate.show_sql">${hibernate.show_sql}</prop> <prop key="hibernate.format_sql">${hibernate.format_sql}</prop> </props> </property> </bean> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean> <!-- 对数据源进行事务管理 --> <tx:annotation-driven transaction-manager="transactionManager" /> </beans>

其所需的参数信息都是从刚才配置好的properties文件中读取。

4. 再次修改applicationContext.xml

我们还需要对这个配置文件做一点点小的修改,加入两行,

1 2 3

<context:component-scan base-package="com.mark.java.entity"/> <!-- 扫描文件(自动将servicec层注入) --> <context:component-scan base-package="com.mark.java.DAO"/>

解释一下,其中com.mark.java.entity则是我们MVC模式中model或称为JavaBean的文件夹目录,其格式应与数据库中字段相同;com.mark.java.DAO是访问数据库要使用DAO,即数据访问对象的目录。我们把这些同service都交给spring管理。最后applicationContext.xml文件如下,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd"> <context:component-scan base-package="com.mark.java.service"/> <context:component-scan base-package="com.mark.java.entity"/> <context:component-scan base-package="com.mark.java.DAO"/> </beans>

5. 建立表User

我们在我们的本地数据库中建立一个表,名为User, 其有两个字段,一个为id主键int类型自增,另一个为usrnamevarchar

具体请戳:https://raw.githubusercontent.com/MarK-YANG/Spring-SpringMVC-Hibernate/master/table.png

6. 创建JavaBean

在entity目录下创建User.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

@Entity @Table public class User implements Serializable { @Id @GeneratedValue private int id; private String username; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } }

注:这里的annotation用的都是JPA的接口。

7. 创建UserDAO

首先创建UserDAO接口,

1 2 3 4

public interface UserDAO { public int save(User u); public List<User> findAll(); }

创建UserDAOImpl实现此接口,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

@Repository public class UserDAOImpl implements UserDAO { @Autowired private SessionFactory sessionFactory; public int save(User u) { return (Integer) sessionFactory.getCurrentSession().save(u); } public List<User> findAll() { Criteria criteria = sessionFactory.getCurrentSession().createCriteria(User.class); return criteria.list(); } }

注:第一个annotation注明这是一个repository,需要被Spring管理,然后自动装载之前在配置文件中配置的 SessionFactory,获取当前session后获取所有的用户,下面修改之前的UserService代码,service封装业务逻辑层代 码,我把每个service方法封装为一个事务。(PS:上面的SessionFactory获取当前Session是依赖于事务的,如果不在某个事务之内, 会报错:No Session found for current thread。)

8.更新UserService

修改UserService接口,

1 2 3 4

public interface UserService { public void saveUsers(List<User> us); public List<User> getAllUsernames(); }

修改UserServiceImpl,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

@Service("userService") @Transactional public class UserServiceImpl implements UserService { @Autowired private UserDAO userDao; public void saveUsers(List<User> us) { for (User u : us) { userDao.save(u); } } public List<User> getAllUsernames() { return userDao.findAll(); } }

注:这个annotation为Transactional,就是指明每个方法是一个事务。

9. 修改MainController

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

@Controller @RequestMapping("/") public class MainController { @Autowired private UserService userService; @RequestMapping("") public String home(){ List<User> us = new ArrayList<User>(); User u = new User(); u.setUsername("MarK"); us.add(u); u = new User(); u.setUsername("Fawofolo"); us.add(u); userService.saveUsers(us); return "index"; } @RequestMapping("/json") @ResponseBody public List<User> json(){ return userService.getAllUsernames(); } }

部署项目,访问http://localhost:8080/spring加入两条新的数据,

访问http://localhost:8080/spring/json查看这两条数据,

结果如下:[{"id":1,"username":"MarK"},{"id":2,"username":"Fawofolo"}]

注:如果发现数据插入两遍,请回头看第一节关于项目部署的介绍。

至此,环境搭建完毕,后面还会有一篇在此环境基础之上做的springMVC的简单实例,敬请期待…

完。


四、总结

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏儿童编程

什么样的人生才是有意义的人生——没有标准的标准答案

【导读】其实我们可以跳出这个小圈圈去更加科客观地看一下这个世界。在夜晚的时候我们仰望天空,浩瀚的宇宙中整个地球只是一粒浮尘,何况地球上一个小小的人类?在漫长的历...

1.8K50
来自专栏儿童编程

我不是算命先生,却对占卜有了疑惑——如何论证“占卜前提”的正确与否

事出有因,我对《周易》感兴趣了很多年。只是觉得特别有趣,断断续续学习了一些皮毛。这几天又偶然接触到了《梅花易数》,觉得很是精彩,将五行八卦天干地支都串联了起来。...

14910
来自专栏儿童编程

《动物魔法学校》儿童学编程Scratch之“外观”部分

导读:本文通过一个案例《动物魔法学校》来学习Scratch语言的“外观”部分。之后通过一系列其他功能的综合运用对作品功能进行了扩展。

19140
来自专栏儿童编程

一张图理清《梅花易数》梗概

学《易经》的目的不一定是为了卜卦,但是了解卜卦绝对能够让你更好地了解易学。今天用一张思维导图对《梅花易数》的主要内容进行概括,希望能够给学友们提供帮助。

31740
来自专栏FSociety

SQL中GROUP BY用法示例

GROUP BY我们可以先从字面上来理解,GROUP表示分组,BY后面写字段名,就表示根据哪个字段进行分组,如果有用Excel比较多的话,GROUP BY比较类...

5.1K20
来自专栏Ken的杂谈

【系统设置】CentOS 修改机器名

18030
来自专栏儿童编程

天干地支五行八卦的对应关系

19290
来自专栏儿童编程

声音功能让儿童编程更有创造性

导读:Scratch中声音功能非常强大,除了常规的音效,你甚至可以模拟各种乐器的各个发音、设置节拍、休止……如果你愿意,甚至可以用它创作一个交响乐。我们可以引导...

13740
来自专栏儿童编程

一张导图梳理欧洲简史梗概

3.1K30
来自专栏儿童编程

儿童创造力教育与编程教育的碰撞——MIT雷斯尼克教授最新理论梗概

儿童编程教育已经在我国各一线二线城市疯狂出现,颇有“烂大街”的趋势。我们不禁要问很多很多问题:

22070

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励