IDEA搭建Spring + Spring MVC + hibernate

工具：IDEA（jdk 1.8） spring和hibernate版本均为4.0以上 推荐使用maven构建项目，相比自己手动导入jar包要方便很多。

1.新建一个maven web项目。

先建一个maven项目，建项目这里不多说， 正确的文件结构： -src ---main ------java（class文件） ------resources（配置文件） ------webapp（web文件） ---test（测试文件） ------java ------resources

2、编写pom.xml文件，导入jar包

导入jar包也是框架整合中比较麻烦的点，常常会导入太多不相关的包，但由于不熟悉又不敢删掉，于是jar包越导越多，到最后框架是搭起来，但jar包却导了十几二十个。

注意点：这里建议的做法是当你不熟悉框架需要导入什么jar包时，可以先导入核心包，然后当运行项目时提示NotFoundClass时，再根据错误提示添加相关的依赖，这样就不会导入多余的jar包。

可以到该网站上去搜索你需要的依赖：mvnrepository.com/

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zznode</groupId>
    <artifactId>admin</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>admin Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <!-- spring版本号 -->
        <spring.version>4.3.10.RELEASE</spring.version>
    </properties>

    <!--   依赖从这开始
     <dependencies>是所有依赖包的父级标签
     其中每添加一个依赖包，就加一个<dependency>标签
     这里已经默认添加了一个测试包，我们需要把所有用到的依赖全部进来
     (用到每个包的依赖信息需要自己找，下面是这个demo需要的依赖包)
     -->
    <!--项目依赖 -->
    <dependencies>
        <!--日志包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.3</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.8.7</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--mysql驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.35</version>
        </dependency>

        <!-- 添加Hibernate依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.8.Final</version>
        </dependency>


        <!--  &lt;!&ndash; spring-date-jpa&ndash;&gt;
          <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.0.6.RELEASE</version>
          </dependency>
      -->
        <!-- https://mvnrepository.com/artifact/javassist/javassist -->
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.12.1.GA</version>
        </dependency>

        <!-- Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--Spring MVC + Spring web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--其他需要的包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!--  &lt;!&ndash; https://mvnrepository.com/artifact/com.google.code.gson/gson &ndash;&gt;
          <dependency>
              <groupId>com.google.code.gson</groupId>
              <artifactId>gson</artifactId>
              <version>2.8.0</version>
          </dependency>-->
        <!--jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.7.0</version>
        </dependency>

        <!--c3p0 start -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

    </dependencies>


    <build>
        <finalName>admin</finalName>

    </build>
</project>

复制代码

其中，注释块 中的依赖导入了框架核心jar包，我们可以提前导入，其他的我们可以根据提示或者需求进行改动。

比如，我的项目中使用的是mysql数据库和c3p0数据源，所以引入MySQL和c3p0的依赖，如果你使用的是其他数据库和数据源就需要做相应的修改。

pom文件中为注释的部分则是在项目运行时提示的jar包缺失引入的依赖，有的是spring框架依赖的包，有的则是servlet或者jsp依赖的，如果第一次搭建时不熟悉可以先不导入，等报错时再引入依赖，这样也可以加深理解。

3、配置文件

这是框架整合最重要的部分。配置文件除了web.xml之外都放在main/resources文件夹中，当然你也可以放在其他自己新建的文件夹下，不过配置文件地址要做相应的修改，这个等会详细说。

配置文件的配置，很多框架整合的教程都不太一样的，这里给出我自己的配置方法和做法。

配置文件主要分为四个：web.xm , beans.xml , spring-mvc.xml , datasource.xml 。

配置步骤分为两步，spring-mvc和spring的整合，hibernate和spring的整合，最后再运行项目。（这也是效率比较高的做法，分开整合，这样即使运行项目有报错也比较好找，而且分部整合不容易乱）

接下来就开始具体配置。

4、spring-mvc和spring整合

spring-mvc.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--启用spring的一些annotation -->
    <context:annotation-config/>

    <!-- 自动扫描com.test.controller包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
    <context:component-scan base-package="com.zznode.admin.controller">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <!--排除@service注解的类-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
    </context:component-scan>


    <!-- 配置注解驱动 可以将request参数与绑定到controller参数上 -->
    <mvc:annotation-driven/>

    <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀(如果最后一个还是表示文件夹,则最后的斜杠不要漏了) 使用JSP-->
    <!-- 默认的视图解析器 在上边的解析错误时使用 (默认使用html)- -->
    <bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/views/"/><!--设置JSP文件的目录位置-->
        <property name="suffix" value=".html"/>
    </bean>

    <!-- springmvc文件上传需要配置的节点-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="20971500"/>
        <property name="defaultEncoding" value="UTF-8"/>
        <property name="resolveLazily" value="true"/>
    </bean>

    <!-- 使用jackjson,默认将返回对象转换为 JSON，如果前面没有在pom文件中添加jackson包的不需要这个配置  -->
    <bean id="stringConverter"
          class="org.springframework.http.converter.StringHttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/plain;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <bean id="jsonConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    </bean>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="stringConverter" />
                <ref bean="jsonConverter" />
            </list>
        </property>
    </bean>
</beans>
复制代码

这是spring-mvc基本的配置，主要是对请求和静态资源映射的配置。

注意点：

1.需要特别注意的是扫描包时要排除service层的类，不然在整合hibernate后，项目运行时会报错。

具体原因看一下这个网址：blog.csdn.net/xiaobao5214…

2.然后就是如果你的包名和结构不一样的，那么扫描的包地址也要记得更换。

web.xml:

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>admin</display-name>

    <!-- 统一编码 解决中文乱码问题-->
    <filter>
        <filter-name>charsetEncoding</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>charsetEncoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- spring MVC 配置-->
    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!-- 此处指向的的是SpringMVC的配置文件 如果配置文件地址和名称不一样需要更改-->
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <!--配置容器在启动的时候就加载这个servlet并实例化-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- spring MVC config end-->

</web-app>
复制代码

将spring-mvc配置文件加到web.xml中，当服务器启动项目时，才会加载springmvc。配置完成后写个例子测试一下。

先在bean包中创建一个User类（测试ackjson）

package com.zznode.admin.bean;

public class User {

	private int id;
	private int age;
	private String name;

	public User(){ }

	public User(int id, int age, String name){
		this.id = id;
		this.age = age;
		this.name = name;
	}

	public int getId() {
		return id;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

复制代码

先在controller包中创建TestController.class：

package com.zznode.admin.controller;

import com.zznode.admin.bean.People;
import com.zznode.admin.bean.User;

import com.zznode.admin.service.PeopleService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;


@Controller
@RequestMapping("test")
public class TestController {

	@Resource(name="peopleService")
	private PeopleService peopleService;

	@GetMapping("/hello")
	@ResponseBody//表示直接输出返回内容，不进行jsp或html跳转，本例是为了写接口，这里直接返回json
    public User test(){

		User user = new User(1,2,"瑞文");
		return user;
	}



}


复制代码

现在的目录结构如下：

启动项目，在浏览器中输入地址：http://localhost:8080/（项目名）/test 。成功可以看到页面。

这里大家有疑问，我返回的是一个对象为什么页面显示的是json数据。可以看我在web.xml配置了jackjson，使用jackjson,默认将返回对象转换为 JSON。有兴趣的话大家可以去了解下。spring mvc现在配置完了，现在去配置hibernate.

5、spring和hibernate整合

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

    <!--配置数据源 这里是使用的是c3p0连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />  <!--数据库连接驱动-->
        <property name="jdbcUrl" value="${jdbc.url}" />     <!--数据库地址-->
        <property name="user" value="${jdbc.username}" />   <!--用户名-->
        <property name="password" value="${jdbc.password}" />   <!--密码-->
        <property name="maxPoolSize" value="40" />      <!--最大连接数-->
        <property name="minPoolSize" value="1" />       <!--最小连接数-->
        <property name="initialPoolSize" value="10" />      <!--初始化连接池内的数据库连接-->
        <property name="maxIdleTime" value="20" />  <!--最大空闲时间-->
    </bean>

    <!--配置session工厂-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.zznode" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> <!--hibernate根据实体自动生成数据库表-->
                <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" />
    </bean>

    <!-- 使用annotation定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
复制代码

applictionContext.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">



    <!-- 注解 -->
    <context:annotation-config />
    <!--扫描-->
    <context:component-scan base-package="com.zznode">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- 导入多个Properties配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <!--要是有多个配置文件，只需在这里继续添加即可 -->
                <value>classpath:datasource.properties</value>
            </list>
        </property>
    </bean>
    <!-- 加载数据源组件 -->
    <import resource="classpath:datasource.xml" />
</beans>
复制代码

注意点：在xml导入properties文件是比较常见，将一些相关的配置数据写到properyties文件中也是常用的方法，利于修改。

常见的另一种导入propertise的方法：在<context:property-placeholder location="classpath:/datasource.properties" />。这种方法spring默认值只导入一个properties，

当有多个properties文件需要导入时，则需要使用另一种方法：

<!-- 导入多个Properties配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <!--要是有多个配置文件，只需在这里继续添加即可 -->
                <value>classpath:datasource.properties</value>                
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>
复制代码

个人比较推荐这种，随着项目扩展，需要导入的配置增多，肯定不止一个properties文件，这种方法更通用。

注意点：datasource.properties文件中的数据库地址，用户和密码根据自己的情况做相应的修改。

修改之前的web.xml文件：

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<display-name>admin</display-name>

  <!-- 统一编码 解决中文乱码问题-->
  <filter>
    <filter-name>charsetEncoding</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>charsetEncoding</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- spring MVC 配置-->
  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <!-- 此处指向的的是SpringMVC的配置文件 如果配置文件地址和名称不一样需要更改-->
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--配置容器在启动的时候就加载这个servlet并实例化-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <!-- spring MVC config end-->

  <!-- 加载spring配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applictionContext.xml</param-value>
  </context-param>
  <!-- listener -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>
复制代码

这就是spring整合hibernate所需要配置的四个文件。文件的加载顺序和包含关系：web.xml→bans.xml→datasource.xml→datasource.properties

注意点：如果你的配置文件名称和存放位置不同，那么你也需要相应的修改。

注意点：一定要记得配置事务，否则操作数据库时项目可能不会报错，但数据库中的数据将不会更新（删除或者修改）。具体可以自行百度事务相关的知识。

配置完成后写个例子测试一下。

在bean包中创建People.class：

package com.zznode.admin.bean;


import javax.persistence.*;

@Entity
@Table(name="people")
public class People {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="id")
	private int id;

	@Column(name="name")
	private String name;

	@Column(name="sex")
	private String sex;

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}

}
复制代码

然后在dao包中创建PeopleDao.class：

package com.zznode.admin.dao;


import com.zznode.admin.bean.People;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;

@Repository("peopleDao")
public class PeopleDao {

	@Resource(name="sessionFactory")
	private SessionFactory sessionFactory;

	/**
	 * 保存对象
	 * @param p
	 * @return
	 */
	public void save(People p){
		sessionFactory.getCurrentSession().save(p);
	}
}

复制代码

在service包中创建PeopleServic.class：

package com.zznode.admin.service;

import com.zznode.admin.bean.People;
import com.zznode.admin.dao.PeopleDao;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

@Service("peopleService")
public class PeopleService {

	@Resource(name="peopleDao")
	private PeopleDao peopleDao;

	@Transactional
	public void save(People p){
		peopleDao.save(p);
	}

	public People newPeople(){
		People p=new People();
		p.setName("小白");
		p.setSex("男");
		return p;
	}


}

复制代码

注意点：在save方法上加@Transactional注解来开启事务。

在DemoController.class中调用save方法保存数据：

package com.zznode.admin.controller;

import com.zznode.admin.bean.People;
import com.zznode.admin.bean.User;

import com.zznode.admin.service.PeopleService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;


@Controller
@RequestMapping("test")
public class TestController {

	@Resource(name="peopleService")
	private PeopleService peopleService;

	@GetMapping("/hello")
	@ResponseBody//表示直接输出返回内容，不进行jsp或html跳转，本例是为了写接口，这里直接返回json
    public User test(){

		User user = new User(1,2,"瑞文");
		return user;
	}

	@GetMapping("/save")
	@ResponseBody
	public People savePeople(){
		People people = new People();
		people.setSex("男");
		people.setName("泰达米尔");
		peopleService.save(people);
		return people;
	}



}



复制代码

启动服务器，访问项目。刷新数据库，如果数据保存到数据库中了，说明框架搭建完成。

访问http://localhost:8080/（项目名）/test 。成功可以看到页面。

转载于:https://juejin.im/post/5bbacc4af265da0aee3f2c44