Maven整合SpringMVC+Hibernate+SpringData框架开发

最新推荐文章于 2021-03-16 17:41:21 发布
最新推荐文章于 2021-03-16 17:41:21 发布
阅读量476 收藏
点赞数
分类专栏： SpringMVC整合 文章标签： jpa spring mvc springdata hibernate maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muangz/article/details/72625606
版权

众所周知，Maven是整理项目的利器，它只需要通过配置文件来管理项目所需要的jar包。

SpringMVC是目前java开发的主流框架模式

hibernate是一个开放源代码的对象关系映射框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库

SpringData是依赖于hibernate的底层数据交互的基础方法，增删改查，排序和分页查询等等。


一 创建Maven工程

具体项目结构如下

创建后会有四个结构分支，[src/mian/java , src/main/resources , src/test/java , src/test/resources]

如果没有的自己进行创建即可， 选中项目右键   -->  Bulid Path -->  New Source Floder 创建即可。


二 配置Web.xml

<?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" xmlns:web="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"
	id="WebApp_ID" version="3.0">
	
	<display-name>SpringMVC整合hibernate和SpringData</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring-hibernate.xml</param-value>
	</context-param>
	
	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener
		</listener-class>
	</listener> 
  
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<description>springMvc配置文件</description>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
	
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>
</web-app>



三 Spring和hibernate的相关配置信息


文件: jdbcConfig.properties

#Mysql 
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://127.0.0.1:3306/imei?useUnicode=true&characterEncoding=utf8
jdbc.username = root
jdbc.password = root


文件: 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/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!-- 启用注解 -->
	<context:annotation-config />
	
	<!-- 指定注解扫描包结构 -->
	<context:component-scan base-package="com.muang" />
	
	<!-- 定义返回客户端视图(JSP)的位置 根据ACTION返回的字符串在VIEWS目录下进行查找 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"/>
		<property name="suffix" value=".jsp"/>
	</bean>
</beans>

文件: spring-hibernate.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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	
	<!-- 指定注解扫描包结构(主要用于junit单元测试,在spring-mvc.xml中配置即可) -->
	<context:component-scan  base-package="com.muang" />
	
	<!-- 引入数据源配置信息 -->
	<context:property-placeholder location="classpath:jdbcConfig.properties"/>
	
	<!-- 1.配置数据源 -->  
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >  
        <property name="driverClassName" value="${jdbc.driver}"/>  
        <property name="url" value="${jdbc.url}"/>  
        <property name="username" value="${jdbc.username}"/>  
        <property name="password" value="${jdbc.password}"/>  
    </bean>  
    
    <!-- 2.配置hibernate工厂 -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    	<property name="dataSource" ref="dataSource"/> <!-- 设置数据源 -->
    	<property name="jpaVendorAdapter" ref="jpaVendorAdapter"/> <!-- 设置springdata jpa处理器 -->
    	<property name="packagesToScan" value="com.muang.entity"/> <!-- 这是指定实体类扫描路径 -->
    	<property name="jpaProperties">  
            <props>
				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
				<prop key="hibernate.show_sql">true</prop> <!-- 是否控制台打印SQL -->
				<prop key="hibernate.format_sql">true</prop> <!-- 是否格式化SQL -->
				<prop key="hibernate.hbm2ddl.auto">update</prop> <!-- 是否自动生成数据表 -->
			</props>
        </property>  
    </bean>
    
    <!-- 配置Spring-data-jpa -->
    <bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="database" value="MYSQL"/>  <!-- 连接mysql -->
		<property name="showSql" value="true"/>  <!-- 是否打印SQL -->
		<property name="generateDdl" value="false"/> 
		<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/> 
    </bean>
    
    <!-- 3.配置事物管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"/>
	</bean>
		
	<!-- 4.配置支持注解的事物 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
	<!-- 5.配置Spring data -->
	<jpa:repositories base-package="com.muang.dao"
		entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager">
	</jpa:repositories>
</beans>


四 配置pom.xml

<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.munag</groupId>
	<artifactId>springdemo2</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>springdemo2 Maven Webapp</name>
	<url>http://maven.apache.org</url>
	
	<properties>
		<spring-version>4.0.3.RELEASE</spring-version>
		<hibernate-version>4.3.5.Final</hibernate-version>
	</properties>
	
	<dependencies>
	    <!-- https://mvnrepository.com/artifact/junit/junit -->
		<dependency>
		    <groupId>junit</groupId>
		    <artifactId>junit</artifactId>
		    <version>4.11</version>
		    <scope>test</scope>
		</dependency>
			    
	    
	    <!-- hibernate -->
	    <!-- https://mvnrepository.com/artifact/org.hibernate.common/hibernate-commons-annotations -->
		<dependency>
		    <groupId>org.hibernate.common</groupId>
		    <artifactId>hibernate-commons-annotations</artifactId>
		    <version>4.0.4.Final</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
		<dependency>
		    <groupId>org.hibernate</groupId>
		    <artifactId>hibernate-core</artifactId>
		    <version>${hibernate-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
		<dependency>
		    <groupId>org.hibernate</groupId>
		    <artifactId>hibernate-entitymanager</artifactId>
		    <version>${hibernate-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
		<dependency>
		    <groupId>org.hibernate.javax.persistence</groupId>
		    <artifactId>hibernate-jpa-2.1-api</artifactId>
		    <version>1.0.0.Final</version>
		</dependency>
		
		<!-- spring -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-aop</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>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-context</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-context-support</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-core</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-commons -->
		<dependency>
		    <groupId>org.springframework.data</groupId>
		    <artifactId>spring-data-commons</artifactId>
		    <version>1.7.1.RELEASE</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
		<dependency>
		    <groupId>org.springframework.data</groupId>
		    <artifactId>spring-data-jpa</artifactId>
		    <version>1.5.1.RELEASE</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-expression</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-jdbc</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-web</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-webmvc</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-orm</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-tx</artifactId>
		    <version>${spring-version}</version>
		</dependency>
		
		
		
		<!-- 其他  -->
		<!-- https://mvnrepository.com/artifact/antlr/antlr -->
		<dependency>
		    <groupId>antlr</groupId>
		    <artifactId>antlr</artifactId>
		    <version>2.7.7</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
		<dependency>
		    <groupId>aopalliance</groupId>
		    <artifactId>aopalliance</artifactId>
		    <version>1.0</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
		<dependency>
		    <groupId>commons-logging</groupId>
		    <artifactId>commons-logging</artifactId>
		    <version>1.1.1</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
		<dependency>
		    <groupId>dom4j</groupId>
		    <artifactId>dom4j</artifactId>
		    <version>1.6.1</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.jboss/jandex -->
		<dependency>
		    <groupId>org.jboss</groupId>
		    <artifactId>jandex</artifactId>
		    <version>1.1.0.Final</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
		<dependency>
		    <groupId>org.javassist</groupId>
		    <artifactId>javassist</artifactId>
		    <version>3.18.1-GA</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.jboss.logging/jboss-logging -->
		<dependency>
		    <groupId>org.jboss.logging</groupId>
		    <artifactId>jboss-logging</artifactId>
		    <version>3.1.1.GA</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/javax.transaction/jta -->
		<dependency>
		    <groupId>javax.transaction</groupId>
		    <artifactId>jta</artifactId>
		    <version>1.1</version>
		</dependency>
		
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.39</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
		<dependency>
		    <groupId>org.slf4j</groupId>
		    <artifactId>slf4j-api</artifactId>
		    <version>1.7.7</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
		<dependency>
		    <groupId>org.apache.httpcomponents</groupId>
		    <artifactId>httpcore</artifactId>
		    <version>4.3.2</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
		<dependency>
		    <groupId>org.apache.httpcomponents</groupId>
		    <artifactId>httpclient</artifactId>
		    <version>4.3.1</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
		<dependency>
		    <groupId>org.apache.commons</groupId>
		    <artifactId>commons-lang3</artifactId>
		    <version>3.4</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
		<dependency>
		    <groupId>javax.servlet</groupId>
		    <artifactId>jstl</artifactId>
		    <version>1.2</version>
		</dependency>

		<dependency>  
		    <groupId>net.sf.json-lib</groupId>  
		    <artifactId>json-lib</artifactId>  
		    <version>2.4</version>  
		    <classifier>jdk15</classifier>  
		</dependency>  
		
		<!-- https://mvnrepository.com/artifact/net.sf.ezmorph/ezmorph -->
		<dependency>
		    <groupId>net.sf.ezmorph</groupId>
		    <artifactId>ezmorph</artifactId>
		    <version>1.0.6</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
		<dependency>
		    <groupId>commons-lang</groupId>
		    <artifactId>commons-lang</artifactId>
		    <version>2.4</version>
		</dependency>
				
		<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
		<dependency>
		    <groupId>commons-collections</groupId>
		    <artifactId>commons-collections</artifactId>
		    <version>3.2.1</version>
		</dependency>
				
		<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
		<dependency>
		    <groupId>commons-beanutils</groupId>
		    <artifactId>commons-beanutils</artifactId>
		    <version>1.8.3</version>
		</dependency>
		
		
		<!-- webservice cxf -->
		
	</dependencies>
	<build>
	  <finalName>springdemo2</finalName>
	</build>
</project>


五 使用Junit进行单元测试（tomcat启动访问地址也可以测试）


实体类代码（entity）：

package com.muang.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="im_user")
public class User implements Serializable{
	private static final long serialVersionUID = -463904210999570141L;

	@Id //主键
	@GeneratedValue //自动增长
	private Integer id;
	
	@Column(length = 40) // 自动创建字段是 指定长度为40
	private String name;
	
	@Column(length = 40)
	private String acctor;
	
	@Column(length = 40)
	private String password;


	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public String getAcctor() {
		return acctor;
	}

	public void setAcctor(String acctor) {
		this.acctor = acctor;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
}

接口类代码（dao）：

package com.muang.dao;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import com.muang.entity.User;

/**
 * 继承JpaRepository接口  实现 基础查询、排序、分页功能
 * 继承JpaSpecificationExecutor 实现查询条件构造功能
 */
public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User>{
	
	/**
	 * 实现Repository接口后, 某些方法可以自动查询， 底层会按照方法命名规则进行解析
	 * 具体常用的命名规则会在下面贴出来
	 */
	
	public List<User> findByName(String name);
	
	@Query("select o from User o where acctor = ?1") //使用 '?序号' 占位符 
	public List<User> getNamesByAcctor(String acctor);
	
	@Modifying // 执行update语句需要注解该注解
	@Query("update User o set o.name = :name where o.id = :id")  // 使用冒号占位符需要在参数前面注解 @Param
	public void updateNameById(@Param("name") String name, @Param("id") Integer id);
}

服务类代码（service）

package com.muang.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class UserServiceImpl{

	@Autowired
	private UserDao dao;
	
	/**
	 * 保存操作添加实物
	 */
	@Transactional
	public void save(User user) {
		dao.save(user);
	}
	
	/**
	 * 删除操作添加实物
	 * @param id
	 */
	@Transactional
	public void deleteById(Integer id) {
		dao.delete(id);
	}
	
	/**
	 * 接口自带的查询, 感兴趣可以看看源码
	 * @return
	 */
	public List<User> findAll() {
		return dao.findAll();
	}
	
	public List<User> getNamesByAcctor(String acctor) {
		return dao.getNamesByAcctor(acctor);
	}
	
	@Transactional  //执行 insert/update/delete操作时候需要注解事务
	public void updateNameById(String name, Integer id) {
		dao.updateNameById(name, id);
		System.out.println("保存成功!");
	}
}

Junit方法测试类： 

package com.muang.service;

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

public class TestUserServiceImpl {
	
	private ApplicationContext ctx = null;
	
	private UserDao userDao = null;
	
	private UserServiceImpl userServiceImpl = null;
	
	@Before
	public void setup() {
		// 加载上下文
		ctx = new ClassPathXmlApplicationContext("spring-hibernate.xml");
		// 从容器中获取bean
		userDao = ctx.getBean(UserDao.class);
		userServiceImpl = ctx.getBean(UserServiceImpl.class);
		System.out.println("setup");
	}
	
	@After
	public void tearDown() {
		ctx = null;
		System.out.println("tearDown");
	}
	
	/**
	 * 测试添加操作
	 */
	@Test
	public void saveUser(){
		User user = new User();
		
		user.setName("12");
		user.setAcctor("admin");
		user.setPassword("1234");

		userDao.save(user);
	}
	
	/**
	 * 测试查询操作
	 */
	@Test
	public void getNamesByAcctor(){
		List<User> users = userDao.getNamesByAcctor("admin");
		for (User user : users) 
			System.out.println("用户名:"  + user.getName() + ", 账号 :" + user.getAcctor() + ", 密码:" + user.getPassword());
	}
	
	/**
	 * 测试删除操作
	 */
	@Test
	public void deleteById(){
		userDao.delete(5);
	}
	
	/**
	 * 测试修改操作  
	 */
	@Test
	public void updateNameById(){
		userServiceImpl.updateNameById("zhangsan", 4);
	}
}

选中方法，右键 Run as ---> Junit Test 执行。   执行结果如下


框架整合到这里就结束了， 上述只是基本的配置，整合其他框架技术还需要各位自己进行拓展。


PS：关于SpringData 方法接口命名规则可以参考下图：




有问题欢迎留言交流。
































                

        

        

    

  


    

      

        

            

              
                
                  随烟飘散
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Spring+SpringMVC+Hibernate整合

				
			

			

				

					weixin_41641941的博客
				

				

					06-10
					
					1万+
					
				

			

		

		

			
				
前几个星期老师在课堂上教了我们Spring和SpringMVC以及Hibernate，但自己一直没有实践过，所以今天就用Spring+SpringMVC+Hibernate整合做了一个用户登陆的模块，好让自己以后搞项目有一个可以参考的流程，期间主要参考的是下面这个博客

https://www.cnblogs.com/xuezhajun/p/7687230.html

第一步：构建一个Maven ...

			
		

	



                

              
                



	

		

			

				
					
ssh整合(spring springmvc hibernate maven spring data jpa)

				
			

			

				

					05-29
				

			

		

		

			
				
spring  springmvc hibernate 整合 使用了maven管理jar  持久层 用了 
spring data jpa

			
		

	



                


  
              

                


	

		

			

				
					
SpringMVC+Spring+Hibernate+Maven框架整合

				
			

			

				

					大白能的博客
				

				

					12-30
					
					430
					
				

			

		

		

			
				
maven项目进行ssh框架整合pom.xml<dependencies>        <!-- spring核心模块 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <ve

			
		

	





	

		

			

				
					
Spring+SpringMVC+hibernate+maven配置文件

				
			

			

				

					laynef的博客
				

				

					05-03
					
					489
					
				

			

		

		

			
				
1.pom.xml文件： &lt;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/x...

			
		

	



		

			
		



	

		

			

				
					
搭建springMvc+spring+hibernate+maven开发环境003

				
			

			

				

					shareing
				

				

					12-03
					
					506
					
				

			

		

		

			
				
记录下解决的错误

1.Eclipse
 Maven 编译错误 Dynamic Web Module 3.0 requires Java 1.6 or newer 解决方案



http://blog.csdn.net/defonds/article/details/47974269




2.The JRE could not be found. Edit the s

			
		

	





	

		

			

				
					
Maven学习笔记(十)-Maven整合SSHSJ(Spring+SpringMVC+Hibernate+Spring Data JPA+JdbcTemplate)框架

				
			

			

				

					fendo
				

				

					06-10
					
					2777
					
				

			

		

		

			
				
一、所用版本与步骤


四个框架所使用的版本:

Spring ---- 4.1.3.RELEASE

Spring mvc ---- 4.1.3.RELEASE
Spring Data JPA----1.3.2.RELEASE
hibernate ---- 4.3.11.Final



其它:

junit ---- 4.12
MySQL ---- 5.1.35

			
		

	





	

		

			

				
					
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA

				
			

			

				

					06-10
				

			

		

		

			
				
在现代Java Web开发中，"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合，被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM"，其中"M"代表Maven，"S"代表Spring，包括Spring核心...

			
		

	





	

		

			

				
					
maven+springmvc+hibernate框架整合开发源代码

				
			

			

				

					04-17
				

			

		

		

			
				
本项目"maven+springmvc+hibernate框架整合开发源代码"提供了一个全面的示例，展示如何有效地将这三个流行的技术集成到一个应用程序中。以下是关于这些框架及其整合的关键知识点：  1. Maven：Maven是一个项目管理和...

			
		

	





	

		

			

				
					
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA+JdbcTemplate

				
			

			

				

					06-11
				

			

		

		

			
				
在"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA+JdbcTemplate"的DEMO中，开发者通常会创建一个Maven工程，配置相关依赖，然后分别设置Spring的配置文件（如`applicationContext.xml`）、SpringMVC的配置文件...

			
		

	





	

		

			

				
					
Spring+SpringMVC+Hibernate+mysql+maven多模块

				
			

			

				

					05-01
				

			

		

		

			
				
标题 "Spring+SpringMVC+Hibernate+mysql+maven多模块" 涉及的是一个常见的Java Web开发技术栈，这个组合常用于构建大型、复杂的Web应用程序。以下是对这些技术及其结合方式的详细解释：  1. **Spring框架**：Spring...

			
		

	





	

		

			

				
					
搭建springMvc+spring+hibernate+maven开发环境002

				
			

			

				

					shareing
				

				

					11-30
					
					405
					
				

			

		

		

			
				
书接上文
我理解的框架整合就是将相应的依赖包引入工程，写好配置文件。

			
		

	





	

		

			

				
					
maven+springMVC+hibernate整合

				
			

			

				

					u010398383的专栏
				

				

					04-14
					
					298
					
				

			

		

		

			
				
再

			
		

	





	

		

			

				
					
SpringDataJpa+Hibernate+Spring搭建环境

				
			

			

				

					anget的博客
				

				

					01-10
					
					304
					
				

			

		

		

			
				
先贴上pom.xml
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation...

			
		

	





	

		

			

				
					
Spring整合SpringDataJpa

				
			

			

				

					weixin_45921969的博客
				

				

					03-16
					
					324
					
				

			

		

		

			
				
Spring整合SpringDataJpa
spring整合jpa的方式是将jpa采用工厂模式管理，我们通过spring的编写方式使用jpa
那么来看看具体代码：
首先是maven的引入：
<?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"

			
		

	





	

		

			

				
					
SpringData Jpa、Hibernate、Jpa 三者之间的关系

				
			

			

				

					学亮编程手记
				

				

					02-23
					
					6275
					
				

			

		

		

			
				
JPA规范与ORM框架之间的关系是怎样的呢？JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现，JBoss应用服务器底层就以Hibernate作为JPA的实现。既然JPA作为一种规范——也就说JPA规范中提供的只是一些接口，显然接口不能直接拿来使用。虽然应用程序可以面向接口编程，...

			
		

	





	

		

			

				
					
运行时报错，HCANN000001: Hibernate Commons Annotations {4.0.2.Final} 等

				
			

			

				

					明天，争取的博客
				

				

					03-15
					
					9544
					
				

			

		

		

			
				
三月 15, 2017 4:42:33 下午 org.hibernate.annotations.common.Version 
INFO: HCANN000001: Hibernate Commons Annotations {4.0.1.Final}
三月 15, 2017 4:42:34 下午 org.hibernate.Version logVersion
INFO: HHH0004

			
		

	





	

		

			

				
					
使用maven搭建SSH项目(spring+springmvc+Hibernate)

					
热门推荐

				
			

			

				

					天地炫舞的博客
				

				

					02-28
					
					2万+
					
				

			

		

		

			
				
本文介绍使用eclipse+maven搭建Spring+SpringMvc+Hibernate项目，以登陆为例：  
1、创建maven项目  
2、把maven项目变为动态网站  
3、搭建spring+springmvc+Hibernate项目 





1 创建maven项目


请点击查看：http://blog.csdn.net/tiandixuanwuliang/article/de...

			
		

	





	

		

			

				
					
Spring整合Hibernate实现Spring Data JPA

				
			

			

				

					云水之路的专栏
				

				

					11-24
					
					6237
					
				

			

		

		

			
				
Spring整合Hibernate实现Spring Data JPA

在上一篇文章《Spring整合Hibernate实现JPA持久化》中，我们已经介绍了怎样在Spring容器中合理地集成Hibernate来实现JPA的ORM机制。但是，细心的读者会发现，上一篇文章中使用了EntityManager来直接与数据库交互，存在这一定的耦合度，更重要的是每当新增或修改新的实体Entity的管理时，都需要重复的实现EntityManager在Dao层的逻辑，有些过于模版化，重复劳动的问题存在，所以这篇文章就来介绍

			
		

	





	

		

			

				
					
ORM--------Hibernate、Mybatis与Spring Data的区别

				
			

			

				

					乐于学习、乐于分享、乐于总结
				

				

					03-04
					
					1万+
					
				

			

		

		

			
				
1.概念:
Hibernate :Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。着力点对象与对象之间关系
Mybatis：MyBatis 本是apache的一个开源项目iBatis,
 2010年这个项目由apache software foundation 迁移到了google c

			
		

	





	

		

			

				
					
使用Maven构建SpringMVC+Hibernate实战教程

				
			

			

				

					
				

			

		

		

			
				
这个过程涉及多个步骤，包括数据库设计、Maven项目的创建、Spring和Hibernate的配置以及SpringMVC的集成。以下是详细的步骤和相关知识点：  1. **数据库设计**  - 首先，我们需要设计符合第三范式(3NF)的数据库表...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值