Maven搭建Springmvc+Spring+Hibernate+html

最新推荐文章于 2018-08-29 16:48:46 发布
原创 最新推荐文章于 2018-08-29 16:48:46 发布 · 3.2k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring mvc #spring #hibernate

本文详细介绍如何使用Maven快速搭建SpringMVC+Spring+Hibernate的Web应用，并配置相关依赖及框架。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近在学前端，由于之前是干Android和Java所以顺便就搞搞Web的东西。于是就摸索了用Maven搭建Springmvc+Spring+Hibernate+html的工程，废话不多说。
工具：Eclipse-Neon.1 Release RC3 (4.6.1RC3)
Maven3.3.9
首先是来创建Maven工程：
这里写图片描述
单击File->New->Maven Project，选择红框中的第二个选项，这个选项可以引用Maven的骨架。

这里写图片描述
在这一步我们选择webapp这个选项来创建我们的web工程。

这里写图片描述
最后一步就是要填写group id和artifact id，其中Package也默认是group id的值。
创建好的工程目录结构：
这里写图片描述
工程创建完毕，接下来就开始搭建工程，我们选择用JavaEE框架时，第一件事情就是找jar包，而Maven最大的方便之处就是解决了jar包的问题。我们只需要在pom.xml文件中配置所需的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.ls.mavenTest</groupId>
  <artifactId>LsProject</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>LsProject Maven Webapp</name>
  <url>http://maven.apache.org</url>
   <!-- 指定maven仓库 -->  
    <repositories>
        <!-- maven自己官方仓库 -->  
        <repository>  
            <id>maven</id>  
            <name>Maven Repository Switchboard</name>  
            <layout>default</layout>  
            <url>http://repo1.maven.org/maven2</url>  
            <snapshots>  
                <enabled>false</enabled>  
            </snapshots>  
        </repository> 

        <!-- <repository>
            <id>sonatype</id>
            <name>Sonatype Repository</name>
            <url>http://repository.sonatype.org/content/groups/public/</url>
        </repository> -->

        <!--  <repository>
            <id>ibiblio</id>
            <name>Ibiblio Repository</name>
            <url>http://mirrors.ibiblio.org/pub/mirrors/maven2/org/acegisecurity/</url>
        </repository> -->

        <repository>
            <id>jboss</id>
            <name>JBoss Repository</name>
            <url>http://repository.jboss.com/maven2/</url>
        </repository>

        <!-- <repository>  
            <id>java-repos</id>  
            <name>Java Repository</name>  
            <url>http://download.java.net/maven/2/</url>  
        </repository>  

        <repository>  
            <id>springsource-repos</id>  
            <name>SpringSource Repository</name>  
            <url>http://repo.spring.io/release/</url>  
       </repository>

       <repository>  
            <id>activiti-repos</id>  
            <name>Activiti Repository</name>  
            <url>https://maven.alfresco.com/nexus/content/groups/public</url>  
       </repository>  

        <repository>  
            <id>activiti-repos2</id>  
            <name>Activiti Repository 2</name>  
            <url>https://app.camunda.com/nexus/content/groups/public</url>  
        </repository>  

        <repository>   
            <id>thinkgem-repos</id>   
            <name>ThinkGem Repository</name>  
            <url>http://git.oschina.net/thinkgem/repos/raw/master</url>  
        </repository>  

        <repository>   
            <id>thinkgem-repos2</id>   
            <name>ThinkGem Repository 2</name>  
            <url>https://raw.github.com/thinkgem/repository/master</url>  
        </repository>  

        <repository>  
            <id>alibaba-opensource</id>  
            <name>alibaba-opensource</name>  
            <url>http://code.alibabatech.com/mvn/releases/</url>  
            <layout>default</layout>  
        </repository>  

        <repository>  
            <id>alibaba-opensource-snapshot</id>  
            <name>alibaba-opensource-snapshot</name>  
            <url>http://code.alibabatech.com/mvn/snapshots/</url>  
            <layout>default</layout>  
        </repository>   -->
    </repositories>  

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <hibernate.version>5.2.6.Final</hibernate.version>
    <!-- log4j日志文件管理包版本 -->
    <!-- <slf4j.version>1.7.10</slf4j.version> -->
    <log4j.version>1.2.17</log4j.version>
  </properties>
  <!-- maven打成war包放到tomcat目录下，即可运行 -->
  <build>
    <finalName>LsProject</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
      </plugin>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <!-- junit测试包 -->
   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <!-- servlet api jar -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>3.0-alpha-1</version>
      <scope>provided</scope>
    </dependency>
    <!-- jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
    <!-- 文件上传 -->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!-- fastJson json数组有关的 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.1.26</version>
    </dependency>

    <!-- 使用 Jackson 把 Java 对象转换成 JSON 字串 -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.11</version>
    </dependency>
    <dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.6.3</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.6.3</version>
    </dependency>
    <!-- mysql驱动包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.29</version>
    </dependency>
    <!-- 阿里巴巴数据源包 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.2</version>
    </dependency>
    <!-- 日志文件管理包 -->
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <!-- <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency> -->
    <!-- aspectjweaver.jar这是Spring AOP所要用到的包 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.7.1</version>
    </dependency>
    <!-- hibernate4 -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${hibernate.version}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>${hibernate.version}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>${hibernate.version}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.1-api</artifactId>
      <version>1.0.0.Final</version>
    </dependency>

 <dependency>
  <groupId>org.freemarker</groupId>
  <artifactId>freemarker</artifactId>
  <version>2.3.23</version>
</dependency>
    <!-- spring mvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- spring3 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</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-context-support</artifactId>
    <version>${spring.version}</version>
</dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</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-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>
</project>

这个就是pom的全配置，同时还列出了几个Maven的远程仓库。国内的网络就不提了。有时候当一些仓库连接不通畅时下载jar包就会奇慢无比。所以多试几个地址还是有好处的。
当然下载jar包还有一种方法就是用命令行到工程目录然后执行mvn clean install -U就可以下载jar包了。
jar包搞定的就是JavaEE框架的配置文件了，这里不在赘述。配置如下：
spring.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-3.0.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.0.xsd
">
    <!-- 引入属性文件 -->
    <context:property-placeholder location="classpath:config.properties" />
    <!-- 自动扫描dao和service包(自动注入) -->
    <context:component-scan base-package="com.ls.dao,com.ls.service" />
</beans>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
      http://www.springframework.org/schema/context  
      http://www.springframework.org/schema/context/spring-context-3.1.xsd  
      http://www.springframework.org/schema/mvc  
      http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    <mvc:annotation-driven />
    <!--静态资源映射 -->
    <mvc:resources mapping="/images/**" location="/WEB-INF/images/" />
    <mvc:resources mapping="/css/**" location="/WEB-INF/css/"/>
    <mvc:resources mapping="/js/**" location="/WEB-INF/js/" />
    <mvc:resources mapping="/html/**" location="/WEB-INF/html/" />
    <bean
    class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean           class="org.springframework.http.converter.StringHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                            <value>text/plain;charset=UTF-8</value>
                        </list>
                    </property>
                </bean>
            </list>
        </property>
    </bean>
    <!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->
    <bean
    class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean                   class="org.springframework.http.converter.StringHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                        <value>text/plain;charset=UTF-8</value>
                        </list>
                    </property>
                </bean>
                <bean                   class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>                          <value>application/json;charset=UTF-8</value>
                        </list>
                    </property>
                </bean>
            </list>
        </property>
    </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" xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
">
    <!-- 配置数据源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20" />
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="20" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0" />
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />
        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000" />
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />
        <!-- 监控数据库 -->
        <!-- <property name="filters" value="stat" /> -->
        <property name="filters" value="mergeStat" />
    </bean>
    <!-- 配置hibernate session工厂 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>
        <!-- 自动扫描注解方式配置的hibernate类文件 -->
        <property name="packagesToScan">
            <list>
                <value>com.phn.model</value>
            </list>
        </property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 注解方式配置事物 -->
    <!-- <tx:annotation-driven transaction-manager="transactionManager" /> -->
    <!-- 拦截器方式配置事物 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" />
            <tx:method name="save*" />
            <tx:method name="update*" />
            <tx:method name="modify*" />
            <tx:method name="edit*" />
            <tx:method name="delete*" />
            <tx:method name="remove*" />
            <tx:method name="repair" />
            <tx:method name="deleteAndRepair" />
            <tx:method name="get*" propagation="SUPPORTS" />
            <tx:method name="find*" propagation="SUPPORTS" />
            <tx:method name="load*" propagation="SUPPORTS" />
            <tx:method name="search*" propagation="SUPPORTS" />
            <tx:method name="datagrid*" propagation="SUPPORTS" />
            <!-- 这里是针对我写的判断用户是否存在数据库的方法的事务，如果不配置的话就会出现no session异常 --> 
            <tx:method name="is*" />
            <tx:method name="*" propagation="SUPPORTS" />
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="transactionPointcut" expression="execution(* com.phn.service..*Impl.*(..))" />
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />
    </aop:config>
</beans>

config.properties注意在配置数据库时要将自己数据库的信息配置正确才行，这里是mysql的配置。

#MySQL \u7684\u914D\u7F6E
hibernate.dialect=org.hibernate.dialect.MySQLDialect
driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
jdbc_url=jdbc:mysql://localhost:3306/phn?useUnicode=true&characterEncoding=utf-8
jdbc_username=root
jdbc_password=123456
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=false
sessionInfoName=sessionInfo
uploadFieldName=filedata
uploadFileMaxSize=20971520
uploadFileExts=txt,rar,zip,doc,docx,xls,xlsx,jpg,jpeg,gif,png,swf,wmv,avi,wma,mp3,mid
uploadDirectory=attached

log4j.properties

log4j.rootLogger=INFO,A1,R
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.Target=System.out
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%c]%m%n 
log4j.appender.R=org.apache.log4j.RollingFileAppender 
log4j.appender.R.File=sshf.log
log4j.appender.R.MaxFileSize=10MB
log4j.appender.R.Threshold=ALL
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH\:mm\:ss,SSS}][%c]%m%n

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"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name></display-name>
    <!-- spring hibernate -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>
    </context-param>
    <!-- openSessionInView配置 -->
    <filter>
        <filter-name>openSessionInViewFilter</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>
    </filter>
    <!--spring mvc 配置 -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup> <!-- 是启动顺序，让这个Servlet随Servletp容器一起启动。 -->
    </servlet>

    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern> <!-- 会拦截/的请求。 -->
    </servlet-mapping>


    <!-- encodeing -->
    <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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <!-- encoding filter for jsp page -->
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <welcome-file-list>
        <welcome-file>/WEB-INF/jsp/login.jsp</welcome-file>
    </welcome-file-list>
</web-app>

至此，配置文件已全部完成。接下来就可以编写代码了。使用框架的好处就是可以相互解耦，层次分明。所以分包时根据相应的名字来命名包。
首先是实体类：UserEntity.java这里采用了注解。所以要注意@column中name的属性要和数据库中的列名一样。

package com.ls.model;

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

/**
 * @author ls
 */
@Table(name="custom")
@Entity
public class UserEntity {
    private int id;
    private String name;
    private String account;
    private String password;
    private String sex; 
    private String phone;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "UID", nullable = false, length = 11)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name = "UNAME", nullable = false, length = 20)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Column(name = "UACCOUNT", nullable = false, length = 20)
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    @Column(name = "UPASSWORD", nullable = false, length = 20)
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Column(name = "USEX", nullable = false, length = 4)
    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    @Column(name = "UPHONE", nullable = false, length = 15)
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
}

接下来是dao层，一个接口一个实现的类
接口UserDao.java

package com.ls.dao;
import com.ls.model.UserEntity;
/**
 * @author ls
 */
public interface IUserDao {
    public boolean isExist(UserEntity user);
}

UserDaoImpl.java

package com.ls.dao.impl;

import javax.annotation.Resource;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import com.ls.dao.IUserDao;
import com.ls.model.UserEntity;

/**
 * @author ls
 */

@Repository("userDao")
public class UserDaoImpl implements IUserDao {
    @Resource
    protected SessionFactory sessionFactory;
    public Session getSession() {
        return sessionFactory.getCurrentSession();
    }
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    public boolean isExist(UserEntity user) {
        Session session = this.getSession();
        String hql = "from UserEntity where username =? and password = ?";
        Query query = session.createQuery(hql);
        query.setString(0, user.getAccount());
        query.setString(1, user.getPassword());
        if (query.list().size() >= 1) {
            return true;
        }
        return false;
    }   
}

然后是service层，同样是一个接口，一个实现类
接口UserService.java

package com.ls.service;
import com.ls.model.UserEntity; 
/**
 * @author ls
 */
public interface UserService {
    public boolean isExist(UserEntity user);
}

UserServiceImpl.java

package com.ls.service.impl;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ls.dao.IUserDao;
import com.ls.model.UserEntity;
import com.ls.service.IUserService;
/**
 * @author ls
 */
@Transactional
@Service("userService")
public class UserServiceImpl implements IUserService {
    @Resource
    private IUserDao userDao;
    @Override
    public boolean isExist(UserEntity user) {
        return userDao.isExist(user);
    }
}

最后就是控制层了
UserController.java

package com.ls.controller;

import java.util.HashMap;
import java.util.Map; 
import javax.annotation.Resource;
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.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import com.ls.model.UserEntity;
import com.ls.service.IUserService;

/**
 * @author ls
 */
@Controller
@RequestMapping("/user")
public class UserController{
    @Resource
    private IUserService userService;
    @ResponseBody
    @RequestMapping(value="/login", method = RequestMethod.POST)
    public Map<String,Object> login( UserEntity user){
        Map<String,Object> map = new HashMap<String,Object>();
        //System.out.println(user.toString());
        boolean loginResult = userService.isExist(user);
        map.put("loginResult", loginResult);
        return map;
    }
}

然后就是View层。是html+js实现的一个简单的登录页面。
login.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>登录</title>
<meta charset="utf-8">
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<link rel="stylesheet" type="text/css" href="../css/login.css">
<script type="text/javascript" src="../js/jquery-1.8.2.min.js"></script>
<script type="text/javascript" src="../js/md5.js"></script>
<script type="text/javascript" src="../js/login.js"></script>
</head>
<body>
    <div>
        UserName:<input type="text" name="account" /> <br/>
        PassWord:<input type="password" name="password" /><br/> 
        <input type="submit" id="loginBtn" value="Login" />
    </div>
</body>
</html>

login.js其中遇到了一个问题就是html中请求数据，url要写全

$(function() {
    $("#loginBtn").click(function() {
        console.log("login");
        var account = $("input[name=account]").val();
        var password = $("input[name=password]").val();
        var user = {
            "account" : account,
            "password" : password
        };
        $.ajax({
            type : "post",
            dataType : "json",
            data : user,
            contentType : "application/x-www-form-urlencoded;charset=UTF-8",
            url : "http://localhost:8080/LSProject/user/login",
            // 同步async: false,（默认是true）;
            // 如上：false为同步，这个方法中的Ajax请求将整个浏览器锁死，
            // 只有test.jsp执行结束后，才可以执行其它操作。
            async : false,
            success : function(data) {
                if (false == data.loginResult) {
                    alert("用户名或者密码错误，请重新登录！");
                } else if (true == data.loginResult) {
                    alert("登录成功！");
                    var indexUrl = window.location.protocol+"//"+window.location.host+"/LSProject/"+"html/index.html";
                    window.location = indexUrl;
                }
            },
            error : function() {
                alert("服务器发生故障，请尝试重新登录！");
            }
        });
    });
});

至此整个工程搭建完毕。
这里写图片描述
小结：可能遇到的问题，在我搭建工程的时候，由于网络问题导致下载的jar包有问题，使我的工程一直跑不起来。具体的报错就是Tomcat的组件无法启动成功，遇到类似问题时可以检查一下jar是否完整。还有就是MySql数据库的信息配置，这个要配置正确。

SSH三大框架的整合(springmvc+spring+hibernate)
03-29
对于刚进入职场的朋友适合的一款整合，本人亲自搭建，jar包和配置文件都在里面，划分了dao永久层，service逻辑层，controller控制层，下载直接导入，然后修改部分配置文件就可以使用，亲测有效。如果导入错误太多，可以尝试自己按照该项目搭建，保证格式没错。喜欢的朋友后面还有ssm整合和s2sh整合。
maven项目（spring+springMVC+hibernate）
06-15
使用maven项目结构搭建的spring+springMVC+hibernate架构项目demo；
maven 创建springmvc项目
QQ_904490352的博客
11-15 267
maven springmvc jetty
spring+springmvc+hibernate 整合
weixin_30488313的博客
10-18 260
三大框架反反复复搭了很多次，虽然每次都能搭起来，但是效率不高。最近重新搭了一次，理顺了思路，整理了需要注意的地方，分享出来。 工具：Eclipse（jdk 1.7） spring和hibernate版本均为4.0以上 推荐使用maven构建项目，相比自己手动导入jar包要方便很多。 1.新建一个maven web项目。（没用过maven的可以i先去了解一下） 注意点：使用Eclips...
使用maven搭建springMVC开发环境
weixin_30299539的博客
08-23 78
1、引入框架所需的包，pom.xml文件中添加如下配置： 　　　　　<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> &l...
Maven搭建SpringMVC+Hibernate项目源码
02-08
Maven搭建SpringMVC+Hibernate项目源码，包括Hibernate二级缓存Ehcache的搭建等等，博文地址：http://blog.csdn.net/fengshizty/article/details/43635305
maven(springmvc+spring+hibernate)
08-05
SSH整合指的是Spring、Struts和Hibernate这三大Java开源框架的集成应用。这三大框架分别负责控制层、视图层和持久层，它们的结合能够构建出功能强大的企业级Web应用程序。 Spring框架是整个SSH整合的核心，它提供了...
用Maven搭建Spring+Spring MVC+Hibernate框架
10-11
本篇文章将深入探讨如何使用Maven作为构建工具，在Eclipse环境中搭建一个整合了Spring、Spring MVC和Hibernate的项目。 首先，让我们了解Maven。Maven是Apache开发的一款项目管理和综合工具，它通过一个项目对象...
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA
06-10
在现代Java Web开发中，"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合，被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM"，其中"M"代表Maven，"S"代表Spring，包括Spring核心...
SpringMVC+Spring+Hibernate(SSH)框架搭建之一
08-08
SSH框架搭建的第一步:搭建好SpringMVC框架 ,并测试成功,引入最少量的库,本人亲自调试和测试通过了,附加了说明文档-错误解决办法
springmvc+spring+hibernate集成jar包
10-03
包含springmvc+spring+hibernate集成所需要的所有的jar包
springmvc+spring+hibernate
08-07
以上是springmvc+spring+hibernate整合基于eclipse，oracle开发
SpringMVC+spring+hibernate整合ssh
09-06
SpringMVC+spring+hibernate整合，此项目为web项目 内有jar包和sql，下载之后改变下数据库，新建一个表，导入sql就可以直接运行！
spring+springMVC+hibernate
08-01
案例包括spring+springMVC+hibernate的完整增删改查，并且附上前端技术
采用maven搭建springmvc+mybaits项目
yinbucheng的博客
05-14 778
前言          最近比较闲，复习搭建一下项目，这次主要使用spring+SpringMVC+Mybatis。项目持久层使用Mybatis3，控制层使用SpringMVC4.1，使用Spring4.1管理控制器，数据库连接池使用druid数据源，该项数据库暂使用MySQL。 1、 数据库表结构以及maven项目结构          数据表非常的简单（不是重点），如下：
SpringMVC+Spring+Hibernate整合
djh_ding的博客
08-29 257
一、web.xml配置 1、配置编码过滤器，CharacterEncodingFilter 2、配置spring文件加载监听器，ContextLoaderListener 3、配置SpringMVC的servlet， DispatcherServlet 4、配置log4j的配置文件监听器，Log4jConfigListener 5、配置系统错误页面 二、applicationContx...
Maven之Spring+SpringMVC+Hibernate搭建
08-29 1934
Spring和Spring MVC是3.2.3.RELEASE 版本的，Hibernate是3.6.10.Final版本的，采用的是Mysql数据库，使用的是JDK1.7版本，Jetty9服务器，这里吐槽一下，maven下开发，tomcat没有jetty好用，虽然tomcat很牛逼，但是真的没有jetty好用，项目的源码地址:https://git.oschina.net/yellowcong/sp
Spring mvc+Spring+hibernate整合
u010643307的博客
04-05 338
有段时间没有更新博客了，跟最近比较忙有关系。无聊搭建个Java web框架，反正好久没有自己搭建框架了，算是练练手了，今天我就来搭建一个框架，技术选型为spring mvc+Spring+hibernate。若想搭建Spring mvc+Spring+Mybatis请看我上篇日志，好了废话不多说，见代码。 1、开发环境：jdk1.7，tomcat6,eclipse版本过高需要设置jdk
Maven+Spring+SpringMVC+Hibernate整合项目教程
在介绍基于Maven、Spring、SpringMVC以及Hibernate的整合项目之前，首先需要了解这些技术各自的用途以及它们在项目开发中的作用。 Maven是一个项目管理工具，它使用一个项目对象模型（POM）文件来管理项目的构建、...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值