maven 整合spring+springmvc+hibernate

最新推荐文章于 2024-10-17 19:11:48 发布
置顶 最新推荐文章于 2024-10-17 19:11:48 发布
阅读量336 收藏
点赞数
分类专栏： spring+hibernate 文章标签： java maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36899792/article/details/72630510
版权

1.配置3个xml文件

web.xml
web.xml主要配置：ContextLoaderListener和DispatcherServer，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

    <!-- 配置web.xml，使其具有springmvc特性，主要配置两处，一个是ContextLoaderListener，一个是DispatcherServlet -->

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

     <!--防止发生java.beans.Introspector内存泄露,应将它配置在ContextLoaderListener的前面
            详细描述见http://blog.csdn.net/jadyer/article/details/11991457  -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>
    <!-- 配置ContextLoaderListener表示，该工程要以spring的方式启动。启动时会默认在/WEB-INF目录下查找applicationContext.xml
作为spring容器的配置文件，该文件里可以初始化一些bean -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

   <!-- spring mvc 配置 -->
    <!-- 配置DispatcherServlet表示，该工程将采用springmvc的方式。启动时也会默认在/WEB-INF目录下查找XXX-servlet.xml作为配置文件，
        XXX就是DispatcherServlet的名字，该文件中将配置两项重要的mvc特性：HandlerMapping,负责为DispatcherServlet这个前端控制器的请求查找Controller；
        ViewResolver,负责为DispatcherServlet查找ModelAndView的视图解析器。
        此处使用指定的配置文件spring-mvc.xml -->
    <servlet>
        <servlet-name>Dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <!--<param-value>/WEB-INF/classes/spring-mvc-servlet.xml</param-value>-->
            <param-value>classpath*:/spring-mvc.xml</param-value>
        </init-param>  
        <load-on-startup>1</load-on-startup>  
    </servlet>
    <servlet-mapping>
        <servlet-name>Dispatcher</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

    <filter>
       <filter-name>SpringOpenSessionInViewFilter</filter-name>
       <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
        <init-param>
      <param-name>singleSession</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>sessionFactoryBeanName</param-name>
      <param-value>sessionFactory</param-value>
    </init-param>
     </filter>
  <filter-mapping>
    <filter-name>SpringOpenSessionInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
    <!-- 字符集过滤器 -->  
    <filter>
        <filter-name>encodingFilter</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>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

     <!-- 加载Log4j的配置****begin -->
  <context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  </listener>
  <!-- 加载Log4j的配置****end -->

    <welcome-file-list>  
        <welcome-file>index.jsp</welcome-file>  
    </welcome-file-list>  
</web-app>

applicationContext.xml
配置ContextLoaderListener表示，该工程要以spring的方式启动。启动时会默认在/WEB-INF目录下查找 applicationContext.xml作为spring容器的配置文件，这里可以初始化一些bean，如DataSource等。代码如下：

<?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-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/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd">


    <!-- 属性文件位置 -->
    <bean id="annotationPropertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:config.properties</value>
            </list>
        </property>
    </bean>

      <!-- 开启注解扫描，但不扫描controller，controller有springmvc扫描，防止mvc事物失效 -->
     <context:component-scan base-package="com.chess.test">
        <context:exclude-filter type="annotation"
        expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置数据源 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="checkoutTimeout" value="30000" />
        <!-- 每60秒检查所有连接池中的空闲连接。默认值: 0，不检查 -->
        <property name="idleConnectionTestPeriod" value="30" />
        <!-- 连接数据库连接池最大空闲时间 -->
        <property name="maxIdleTime" value="30" />
        <!-- 连接池初始化连接数 -->
        <property name="initialPoolSize" value="5" />
        <property name="minPoolSize" value="5" />
        <property name="maxPoolSize" value="20" />
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 -->
        <property name="acquireIncrement" value="5" />
    </bean>
    <!-- 配置hibernate的SessionFactory -->
            <bean id="sessionFactory"
          class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <!-- 注入数据源 相关信息看源码 -->
        <property name="dataSource" ref="dataSource" />
        <!-- hibernate配置信息 -->
        <property name="hibernateProperties">
            <props>
                <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>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>

                <!-- 开启二级缓存 ehcache -->
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
                <prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.cache.provider_configuration_file_resource_path}
                </prop>
            </props>
        </property>
        <!-- 扫描hibernate注解配置的entity -->
        <property name="packagesToScan" value="com.chess.test.model" />
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager"/>



</beans>

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-4.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!-- 启用spring mvc 注解 -->
    <context:annotation-config />
      <!-- 扫描注解  只扫描controller，防止service层事物失效-->
    <context:component-scan base-package="com.chess.test.controller"/>

    <!-- 处理请求时返回json字符串的中文乱码问题 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 避免IE执行AJAX时,返回JSON出现下载文件 -->
    <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <!-- 跳转视图配置 -->
    <bean name="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"><!-- 跳转到JSP的视图 -->
            <value>org.springframework.web.servlet.view.JstlView</value>
        </property>
        <!-- 相关JSP页面路径配置 -->
        <property name="prefix"><!-- JSP页面前缀 -->
            <value>/WEB-INF/jsp/</value>
        </property>
        <property name="suffix"><!-- JSP页面后缀 -->
            <value>.jsp</value>
        </property>
    </bean>
    <bean name="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="UTF-8" />
    </bean>
</beans>

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <diskStore path="java.io.tmpdir"/>
    <!-- DefaultCache setting. -->
    <defaultCache
            maxElementsInMemory="1000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="1000000"
            overflowToDisk="true"
            memoryStoreEvictionPolicy="LRU">

    </defaultCache>

</ehcache>

config.properties

#application configs

#jdbc c3p0 config
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
jdbc.username = root
jdbc.password = root

#hibernate config
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = true
hibernate.format_sql = false
hibernate.hbm2ddl.auto = update
hibernate.cache.use_second_level_cache = false
hibernate.cache.use_query_cache = false
hibernate.current_session_context_class=thread
hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory
hibernate.cache.provider_configuration_file_resource_path = ehcache.xml

log4j.properties

### set log levels ###
log4j.rootLogger = DEBUG

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

2.添加必须的包依赖到pom.xml

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.chess</groupId>
  <artifactId>test</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>pass Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
    <spring.version>4.1.5.RELEASE</spring.version>
    <hibernate.version>4.3.8.Final</hibernate.version>
    <jackson.version>2.5.0</jackson.version>
    <slf4j-version>1.7.5</slf4j-version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>commons-beanutils</groupId>
      <artifactId>commons-beanutils</artifactId>
      <version>1.8.3</version>
    </dependency>
    <dependency>
      <groupId>commons-collections</groupId>
      <artifactId>commons-collections</artifactId>
      <version>3.2.1</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>1.4</version>
    </dependency>

    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.4</version>
    </dependency>

    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.1</version>
    </dependency>

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.1</version>
    </dependency>

    <dependency>
      <groupId>commons-pool</groupId>
      <artifactId>commons-pool</artifactId>
      <version>1.6</version>
    </dependency>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

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

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

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

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
      <scope>test</scope>
    </dependency>
    <!-- 使用SpringMVC需配置 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- 关系型数据库整合时需配置 如hibernate jpa等 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- hibernate -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${hibernate.version}</version>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>${hibernate.version}</version>
    </dependency>
    <!-- 二级缓存ehcache -->
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>2.9.0</version>
    </dependency>
    <!-- log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <!--slf4j-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j-version}</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>${slf4j-version}</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-simple</artifactId>
      <version>${slf4j-version}</version>
      <scope>runtime</scope>
    </dependency>
    <!-- mysql连接 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.34</version>
    </dependency>
    <!-- c3p0数据源 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5-pre10</version>
    </dependency>
    <!-- json -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.3</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jackson.version}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson.version}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <!-- aop -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.4</version>
    </dependency>

    <!-- servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>3.0-alpha-1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.1.5.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>test</finalName>
  </build>
</project>

3.写一个简单的新增功能验证项目

AcctUser.java

package com.chess.test.model;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;


/**
 * AcctUser generated by hbm2java
 */
@Entity
@Table(name = "acct_user")
public class AcctUser implements java.io.Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 6980093847795726310L;
    private Long id;
    private String nickName;
    private String telephone;
    private Date registerTime;

    public AcctUser() {

    }

    public AcctUser(Long id, String nickName) {
        this.id = id;
        this.nickName = nickName;
    }

    public AcctUser(Long id, String nickName, String telephone,
            Date registerTime) {
        this.id = id;
        this.nickName = nickName;
        this.telephone = telephone;
        this.registerTime = registerTime;
    }

    @Id
    @Column(name = "id", unique = true, nullable = false, length = 36)
    public Long getId() {
        return this.id;
    }

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

    @Column(name = "nick_name", nullable = false)
    public String getNickName() {
        return this.nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Column(name = "telephone")
    public String getTelephone() {
        return this.telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "register_time", length = 19)
    public Date getRegisterTime() {
        return this.registerTime;
    }

    public void setRegisterTime(Date registerTime) {
        this.registerTime = registerTime;
    }


}

UserDao.java

package com.chess.test.dao;

import java.util.List;

import com.chess.test.model.AcctUser;

public interface UserDao {
    /**
     * 查询所有菜单
     * @return
     */
     List<AcctUser> getAllList();
}

UserDaoImpl.java

package com.chess.test.dao.impl;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.chess.test.dao.UserDao;
import com.chess.test.model.AcctUser;
@SuppressWarnings("unchecked")
@Repository("userDao")
public class UserDaoImpl implements UserDao {

    @Override
    public List<AcctUser> getAllList() {
        List<AcctUser> list = getListByHQL("from AcctUser");
        return list;
    }

}

Test.java

package com.chess.test.test;

import java.util.Date;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.junit.runner.RunWith;
import com.chess.test.model.AcctUser;
import com.chess.test.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:applicationContext.xml","classpath:spring-mvc.xml"})
public class UserTest extends AbstractJUnit4SpringContextTests{
        @Autowired
        private UserService userService;
        @Test
        public void  addMenu(){
            AcctUser user = new AcctUser();
            user.setId(2L);
            user.setNickName("name");
            user.setRegisterTime(new Date());
            user.setTelephone("18658556903");
             userService.addUser(user);
        }
}
qq_36899792
关注
专栏目录
Spring+SpringMVC+Hibernate整合
weixin_41641941的博客
06-10 1万+
前几个星期老师在课堂上教了我们Spring和SpringMVC以及Hibernate，但自己一直没有实践过，所以今天就用Spring+SpringMVC+Hibernate整合做了一个用户登陆的模块，好让自己以后搞项目有一个可以参考的流程，期间主要参考的是下面这个博客 https://www.cnblogs.com/xuezhajun/p/7687230.html 第一步：构建一个Maven ...
Maven整合Spring，Spring mvc4.1.6,Hibernate4.3.10项目搭建总结
lgxzzz的博客
01-26 164
先上详细的配置文件，在上说明，让大家看完例子后更能清晰的对项目有个认识。 该框架集合的功能模块主要包含以下功能包： guavaAspectJapache commonlogSpringHibernatePOIjacksonoraclequartz 1，web.xml myapp contextConfigLocation /WEB-INF/applicationContext.xml org.springframework.web.conte
SpringMVC+Spring+Hibernate+Maven框架整合
大白能的博客
12-30 437
maven项目进行ssh框架整合pom.xml<dependencies> <!-- spring核心模块 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <ve
使用Maven 整合Spring和hibernate 适合初级接触的学者
yulinlin_fei的专栏
07-16 3904
本文，主要介绍Spring 和 hibernate怎么去整合，废话就不多说了，如果不知道spring 和hibernate 是干嘛的，还请去问问度娘哈。下面开始一步一步搭建： 工具： Idea  一、先搭建Spring   1.新建一个maven项目：至于填写项目名称什么的就不一一介绍了 这里我的idea没有自动生成test文件夹，需要大家自己建一下，之后的项目目录如下图所示：
使用Maven整合Spring+SpringMVC+Hibernate
WchStrife的博客
07-28 5616
使用Maven构建SpringMVC项目演示代码地址：https://github.com/wchstrife/spring-mvc-demo 本篇文章主要参考了：http://www.cnblogs.com/xrog/p/6359706.html 1. 使用IDEA创建Maven项目 需要注意的就是选择模板的的时候要选择Web 2. 设置pom.xml将所需要的jar包导入 这里我们
Spring+SpringMVC+Hibernate+Maven的整合
夏倩倩的博客
08-10 1489
主要记录对于整合Spring、SpringMVC、Hibernate以及Maven的一个步骤以及相关需要的配置文件，和需要注意的地方。PS：师傅要我整合这个的时候，看了网上很多例子，现在整合一下。Spring+SpringMVC+Hibernate+Maven的整合主要有以下几步： 创建数据库表，本次使用的是PostgreSQL； 创建Maven工程； 添加项目需要的所有库； 创建包结构； 创建配置
使用maven搭建spring+springMVC+hibernate框架
allakk的博客
06-18 1141
上一篇是搭建了web环境，接下来整合spring、springMVC以及hiebrnate，其中主要就是配置文件的问题，pom文件等。 本篇是使用spring-version为4.3.3.RELEASE，hibernate-version为4.2.21.Final 这里直接贴上pom文件，包括spring，springMVC，hibernate，mysql等完整配置，并且包括EntityManag...
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA
06-10
在现代Java Web开发中，"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合，被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM"，其中"M"代表Maven，"S"代表Spring，包括Spring核心...
idea工具创建的Spring+SpringMVC+Hibernate+maven项目
12-24
标题中的"idea工具创建的Spring+SpringMVC+Hibernate+maven项目"指的是使用IntelliJ IDEA这个集成开发环境（IDE）构建的一个Java Web项目，该项目整合了四个关键的技术框架：Spring、SpringMVC、Hibernate以及Maven...
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA+JdbcTemplate
06-11
在"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA+JdbcTemplate"的DEMO中，开发者通常会创建一个Maven工程，配置相关依赖，然后分别设置Spring的配置文件（如`applicationContext.xml`）、SpringMVC的配置文件...
Spring+SpringMVC+Hibernate+Maven框架搭建及配置文件源码
04-28
在"Spring+SpringMVC+Hibernate+Maven框架搭建及配置文件源码"这个项目中，开发者可能已经包含了这些框架的配置文件，例如Spring的applicationContext.xml、SpringMVC的servlet-context.xml、Hibernate的hibernate....
基于Maven 搭建Spring + SpringMVC源码.rar
11-07
本篇文章将深入探讨如何使用Maven来搭建一个整合了Spring和Spring MVC的项目，并解析源码，帮助你理解这两个框架是如何协同工作的。 1. Maven简介： Maven是一个项目管理工具，它通过读取项目配置文件（pom.xml）...
java 异常包装
最新发布
fdvvg的博客
10-17 213
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 354
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 669
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 520
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
Springboot api http并发测试请求
nsa65223的专栏
10-11 358
【代码】Springboot api http并发测试请求。
spring task的使用场景
qq_40603125的博客
10-13 324
spring任务调度框架约定的时间。
【Java 22 | 8】 深入解析Java 22 ：Pattern Matching 特性详解
颜淡慕潇
10-17 1240
Java 22 进一步扩展了模式匹配（Pattern Matching）功能，简化了类型检查和条件表达式的使用。此特性不仅提升了代码的可读性，还减少了常见的错误。以下是对 Java 22 中模式匹配的详细介绍，包括基础概念、增强特性、使用场景、示例代码，以及如何在实际项目中有效利用模式匹配
Spring+SpringMVC+Hibernate环境搭建教程：图文详解
本文档详细介绍了如何在IntelliJ IDEA集成开发环境中搭建Spring、SpringMVC和Hibernate项目的环境。首先，我们将通过图文并茂的方式，一步步指导你完成项目的基本配置。 1. 工具准备 - 选用的IDE是 IntelliJ IDEA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值