Hibernate的使用(三)

最新推荐文章于 2023-01-13 17:10:07 发布

奔跑的代码君

最新推荐文章于 2023-01-13 17:10:07 发布

阅读量286

点赞数

分类专栏： work

本文链接：https://blog.csdn.net/qq_38353700/article/details/85219996

版权

work 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一，本节内容

前两节记录了hibernate通过xml，以及注解的使用，本节将通过hibernate注解的功能搭建一个Spring+Hibernate+SpringMvc的项目。本文需要对spring有一定的基础和认识，另外写该博客也是方便自己以后需要的时候不用到处搜(好多网上的例子也不对自己的胃口 =。=)，好了正式开始。

二，开始前的准备工作

本人在搭建整个环境时出了好多问题，所以在开始前把我遇到的问题记录下来，一方面方便自己，另一方面希望在未来也可以帮助到遇到同样问题的朋友。
(1)log4j的使用
log4j是apache提供的一个日志工具，它可以通过配置把项目运行中的日志输出到控制台，文件等，而且你还可以设置日志输出的格式，功能十分强大。之所以使用日志功能是方便我们在搭建环境时出现问题可以快速定位问题，如果没有这些日志，真要排查问题还是很困难的，在使用Spring时很多工作完成后都会打印日志的。
log4j使用方式：首先时在项目中加入log4j的jar包依赖：

<dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
   
    <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>1.7.25</version>
       <scope>test</scope>
    </dependency>
    <dependency>
  
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>

在项目的src路径下(默认的路径)建一个log4j.properties的文件，这样项目在启动时就会读取该配置文件。我们的项目直接把日志信息打印到控制台就行了，至于其他的设置不是本文探讨的重点。

### set log levels ###
log4j.rootLogger = INFO,stdout
### console ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =[%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

三，环境的搭建

新建一个maven的web项目，Spring使用4.2.5.RELEASE，hibernate使用3.6.10.Final，此外数据库使用mysql，所以还需要mysql的驱动，整个项目的pom文件如下：
注意：由于，我也是第一次搭建这样的环境，所以可能jar包依赖并不是最精简的，但在本人的环境下是正常的，所以请依据个人情况选择相应的jar包进行依赖就好了。

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mytest</groupId>
  <artifactId>ssh</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>ssh Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
		<!-- 文件拷贝时的编码 -->
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<!-- 编译时的编码 -->
		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
		<java-version>1.8</java-version>
		<org.springframework-version>4.2.5.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- 添加hibernate的依赖 开始-->
    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency> 
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.1.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <!-- 添加hibernate的依赖 结束-->
     <!-- mysql数据库的驱动包 -->
    <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
      </dependency>
    <dependency>
      <!-- hibernate核心文件 -->
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>3.6.10.Final</version>
   </dependency>
   <!-- 动态创建，修改Java字节码的文件，hibernate使用，这玩意需要jdk1.8,坑了我好久 -->
   <dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.20.0-GA</version>
</dependency>
 <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
</dependency>
      <dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework-version}</version>
			<exclusions>
				<!-- Exclude Commons Logging in favor of SLF4j -->
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- spring框架包 start -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>

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

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<!-- websocket -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-websocket</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-messaging</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
        <dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.8.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.8.0</version>
		</dependency>
		<!-- 文件上传 -->
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.1</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
<!--     https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>1.7.25</version>
       <scope>test</scope>
    </dependency>
<!--     https://mvnrepository.com/artifact/org.slf4j/slf4j-nop -->
   <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-nop</artifactId>
     <version>1.7.2</version>
   </dependency>
  <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api-->
   <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
  <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
  <dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
 </dependency>
</dependencies>
  <build>
    <finalName>ssh</finalName>
    <plugins>
			 <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>utf-8</encoding>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
        </plugin>
        </plugins>
  </build>
</project>

整个项目将在tomcat的环境中跑，所以添加了maven对tomcat插件的依赖。
maven的版本3.5.4。
接下来的步骤就是Spring集成SpringMvc，然后再整合hibernate，由于本篇文章的内容为hibernate的使用，所以详细步骤便不再叙述，只贴出相应的配置文件。
(1)web.xml

<?xml version="1.0" encoding="UTF-8"?>
  <web-app  xmlns:xsi="http://www.w3.org/2001/XMLSchema-  instance"  xmlns="http://xmlns.jcp.org/xml/ns/javaee"  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaeehttp://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"  version="3.1">
  <display-name>ssh</display-name>
  <context-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:config/spring/applicationContext.xml</param-value>
  </context-param>
  <!-- 防止Spring内存溢出监听器，放在最前面，因为servlet3.0调用listener的顺序是根据在web.xml中定义的顺序决定的 -->
     <listener>
          <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
     </listener>
     <listener>
       <listener-class>
          org.springframework.web.util.Log4jConfigListener
       </listener-class>
     </listener>
    
  <listener>
<!--         ContextLoaderListener监听器的作用就是启动Web容器时，自动装配ApplicationContext的配置信息,配置 -->
<!--               信息key为contextConfigLocation，value可以有多个，之间用逗号分隔-->
          <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>
     <servlet>
          <servlet-name>DispatherServlet</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:config/spring/spring-mvc.xml</param-value>
          </init-param>
          <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
          <servlet-name>DispatherServlet</servlet-name>
          <url-pattern>/</url-pattern>
     </servlet-mapping>
     <filter>
          <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
          <url-pattern>/*</url-pattern>
     </filter-mapping>
</web-app>

注意上面配置有log4j的listener。
（2）spring-mvc.xml

<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">

    <!-- 开启包扫描 ，只扫描controller--> 
    <context:component-scan base-package="com.controller" >
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <!-- 开启注解 --> 
        <mvc:annotation-driven></mvc:annotation-driven>        
    <!-- 对模型视图名称的解析,在请求时模型视图名称添加前后缀 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="" /> <!-- 前缀 -->
        <property name="suffix" value=".html" />   <!-- 后缀 -->
    </bean>
    
    <!-- 对静态资源的映射-->
    <mvc:resources mapping="/js/**" location="/js/" />
    <mvc:resources mapping="/css/**" location="/css/" />
    <mvc:resources mapping="/*.html" location="/" />
</beans>

（3）Spring整合hibernate
数据库使用mysql，使用c3p0来作为数据库连接池，配置文件applicationContext.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:aop="http://www.springframework.org/schema/aop"
		xmlns:tx="http://www.springframework.org/schema/tx"
		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/aop
		    http://www.springframework.org/schema/aop/spring-aop.xsd
			http://www.springframework.org/schema/tx 
			http://www.springframework.org/schema/tx/spring-tx.xsd
			http://www.springframework.org/schema/context   
			http://www.springframework.org/schema/context/spring-context.xsd  ">
     <!-- 加载数据库配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"
        file-encoding="utf-8" ignore-unresolvable="true" />
    <!-- 配置扫描注解,不扫描@Controller注解 -->
  <context:component-scan base-package="com.*">
      <!-- 配置不扫描controller -->
      <context:exclude-filter type="annotation"
        expression="org.springframework.stereotype.Controller" />
   </context:component-scan>
    <!--创建jdbc数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${db.driverClassName}" />
		<property name="jdbcUrl" value="${db.jdbcUrl}" />
		<property name="user" value="root" />
		<property name="password" value="root" />
		<property name="initialPoolSize" value="${db.initialPoolSize}"></property>
		<property name="maxPoolSize" value="${db.maxPoolSize}"></property>
		<property name="minPoolSize" value="${db.minPoolSize}"></property>
	</bean>
        
<!-- 配置SessionFactory ：1）读取hibernate.cfg.xml文件-->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<!-- 	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">     -->
	    <property name="dataSource" ref="dataSource"></property>
		<property name="configLocation"  value="classpath:config/hibernate.cfg.xml"></property>
<!-- 		hibernate自动扫描 实体类 -->
<!--         <property name="packagesToScan" value="com.entity"> -->
<!--        <property name="packagesToScan"> -->
<!--          <list> -->
<!--            <value>com.entity</value> -->
<!--          </list> -->
<!--        </property> -->
<!--             <list> -->
<!--                 <value>com.entity.User</value> -->
<!--             </list> -->
<!--         </property>    -->
      <!-- 这是配置扫描xml的，无语 -->
<!--       <property name="mappingDirectoryLocations" value="/com/entity/"> -->
<!-- 		</property> -->
<!--         <property name="hibernateProperties"> -->
<!--             <props> -->
<!--                 <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop> -->
<!--                 <prop key="hibernate.show_sql">true</prop> -->
<!--                 <prop key="hibernate.format_sql">true</prop> -->
<!--                 <prop key="hibernate.current_session_context_class">thread</prop> -->
<!--             </props> -->
<!--         </property> -->
       <property name="packagesToScan">
          <list>
             <value>com.entity</value>
          </list>
       </property>
	</bean>
	<!-- 1 指定事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>			
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

其中 jdbc.properties是数据库的连接信息，此处发生了一个小插曲，我连接数据库时始终被拒绝了，但是本地访问是正确的，最后猜想可能是在引用时出了问题，便直接显式的使用了user和password，最后便没有问题了，我也是很无语。。。查了好多资料。下面是数据库的配置文件

db.driverClassName=com.mysql.jdbc.Driver
db.jdbcUrl=jdbc:mysql://127.0.0.1:3306/mytest?&serverTimezone=CTT
db.user=root
db.password=root
db.initialPoolSize=3
db.maxPoolSize=30
db.minPoolSize=3

此外，仔细观察applicationContext.xml文件，你会发现在配置hibernate的包扫描时我注释了好多，那是因为我自己踩了好多坑啊，具体问题，之后会进行解释。
hibernate的配置可以直接在该文件里写，见我注释掉的部分，也可以通过配置文件，我这里通过指定配置文件的位置进行加载，

<property name="configLocation"  value="classpath:config/hibernate.cfg.xml"></property>

hibernate.cfg.xml文件如下：

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    <!-- 配置hibernate的基本属性 -->
        <!-- 配置数据源 ,因为需要把数据源配置到IOC容器中,所以这里不需要再配置-->
        <!-- 配置数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 显示并格式化sql语句 -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <!-- 自动生成数据库表结构 -->
        <property name="hbm2ddl.auto">update</property>
        <!-- 使用getCurrentSession方式打开会话 -->
        <!-- 是保证能从当前线程中获取到事务会话的方式。 --> 
<!--         <property name="hibernate.current_session_context_class">thread</property> --> 
        <!-- 关联的*.hbm.xml也在容器配置sessionFactory实例时在进行配置,这里也不再配置 -->
    </session-factory>
</hibernate-configuration>

通过packagesToScan属性设置了自动扫描com.entity下的类，然后与数据库中的表进行映射,其中list属性中可以加多个value。

 <property name="packagesToScan">
          <list>
             <value>com.entity</value>
          </list>
       </property>

到此所有的配置结束，可能有好多关于Spring的配置等等都没有讲，读者可以留言问我，或者自行进行学习。
（4）整个项目结构一览
在这里插入图片描述
四，hibernate注解的使用
@Entity
@Table(name="***")
该注解作用于类上,表示该类与数据库中的一个表是映射关系，其中name属性指定表的名字。
@Id
该注解用于表中的主键字段上，一般为id，此外还可以设置主键的产生原则，像mysql有主键自增的功能就可以选择该策略，但oracle等可能就需要借助序列来产生主键了。
@GeneratedValue(strategy=GenerationType.AUTO)
表示不指定主键产生的策略，而是根据底层数据库支持的功能来决定的。其他的策略可以在使用的时候再查
@Column
表示标记的字段是数据库表中的列，它的name属性可以用来指定列的名字，这样实体类中属性便可以不用与数据库中的字段名相同了。

注意：上面的注解都是使用了javax.persistence包下的功能，这是java定义的jpa规范，hibernate实现了该规范，当然还有别的实现。

五，正式使用

在src/main/java中先建4个包，如下：

在这里插入图片描述
主要是controller-控制层，dao-数据库访问层，entity-模型层，service-服务层.
本次任务模拟用户的登录：
（1）首先是entity层：新建User类，存储用户的基本信息

package com.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="tb_user")
public class User {
  
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="id")
	private int id;
	
	@Column(name="name",length=20,nullable=false)
	private String name;
	
	@Column(name="age")
	private int age;
	
	@Column(name="account")
	private String account;
	
	@Column(name="password")
	private String password;
   //省略get,set方法
   }

（2）dao层，定义user登录的接口，以及其实现类，这里直接贴出其实现类，UserDaoImpl

package com.dao.impl;

import javax.annotation.Resource;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import com.dao.UserDao;
import com.entity.User;

@Repository("userDao")
public class UserDaoImpl implements UserDao{
    @Resource
	private SessionFactory sessionFactory;
	
	public User canLogin(String account, String password) {
	
		String sql = "select * from tb_user where account = '"
		              +account+"' and password = '"+password+"'";
		Session session = sessionFactory.getCurrentSession();
		SQLQuery query = session.createSQLQuery(sql).addEntity(User.class);
		User user = (User) query.uniqueResult();
		return user;
	}
}

上面定义了根据用户的账号和密码进行查询的操作，注意sql中关键字用单引号包起来呀，另外还要注入sessionFactory，获取session对象进行数据库操作，该bean在spring的配置文件中已经定义，另外操作完成后session也不用手动关闭，spring容器会自行维护。
（3）Server层

package com.service;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.dao.UserDao;
import com.entity.User;

@Service("userService")
@Transactional
public class UserService {
   
	@Resource(name="userDao")
	private UserDao userDao;
	
	public User canLogin(String account,String password) {
		
		return this.userDao.canLogin(account, password);
	}
}

注意这里注入了UserDao,name为userDao，但实际上是由UserDaoImpl生成的，一定要注意名字要对上，不然会注入失败的。此外，service层使用了@Transactional注解用于事务处理，Spring提供的事务有两种，一种是声明式的即通过aop配置切面，另一种就是代码式，直接在类上使用注解交给Spring进行事务处理，这些需要在spring的配置文件中进行定义。
(4)Controller层
该层用于处理用户的请求，把相应的视图信息返给用户

package com.controller;

import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.entity.User;
import com.service.UserService;

@Controller
public class UserController {
    
	@Autowired
	private UserService userService;
	
	@RequestMapping("/userLogin")
	public  String userLogin(
			@RequestParam("account")String account,
			@RequestParam("password")String password,
			HttpSession session) {
		
		User user = this.userService.canLogin(account, password);
		if(user!=null)
		   {
			session.setAttribute("user", user);
			return "index";
		   }
		else
			return "login";
		
	}
}

这里注入了userService，然后调用service层的方法，验证成功会返回User对象，然后将用户信息保存在session中返回主页；失败，返回登录页面。

六，验证结果

在pom文件中我们已经定义了tomcat插件，所以可以直接运行，在eclipse中点击run as ,然后选择maven build，输入goals为：tomcat7:run
在这里插入图片描述
如果maven执行失败，报无效的java版本什么的，那就点击上图中的jre，把jdk换为1.8的版本就好了，因为我们在pom文件中指定了项目的jdk版本为1.8呀。(要是不指定，maven clean后直接就变成1.5了，1.5是maven默认的jdk版本好像)
之后，要是没有什么错误，项目就会成功跑起来，控制台上也会打印出各种信息，这就是使用日志的好处啊。

访问login.jsp就是一个简单的表单提交。数据库中我提前建好了一个用户，然后直接用账号，密码登录就好了：
控制台打印的sql信息：
在这里插入图片描述
登录成功，跳转到index.jsp:

到此，一个基于spring+springmvc+hibernate的项目就完成了。下一节，着重讲解在搭建的过程中我所遇到的坑。

奔跑的代码君

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate的使用(三)

一，本节内容上一节记录了hibernate通过xml配置的使用，本节将记录hibernate注解功能的使用，通过注解可以很方便的使用hibernate，减少了配置文件xml的使用量。另外本节将搭建一个Spring+Hibernate+SpringMvc的项目，本文假设读者都已经对spring等已经有啦很好的认识，好了正式开始。二，开始前的准备工作本人在搭建整个环境时出了好多问题，所以在开始前...
复制链接

扫一扫

专栏目录