IDEA maven SSH Oracle 整合实现简易用户登录

本方大部分内容来自 http://blog.csdn.net/sysushui/article/details/73722870?locationNum=11&fps=1因为我使用的Oracle12c数据库，一些配置不同，导致遇到很多坑，因此将我遇到的问题与解决办法分享，希望大家少走弯路

前言

        a）使用maven搭建一个SSH项目（基本的项目框架）

        b）实现一个简易的登录程序，涉及到Oracle12c，Hibernate, Spring, Struts

        c）如何使用IDEA2017搭建maven项目

所有的代码都可以在 github 下载

一. 前期准备

1）环境

        a）安装IDEA

        b）安装Oracle

二. 建立项目

1）IDEA新建maven项目，相关截图如下：

2）完善目录结构，主要完善如下：

    2.1）在src/main/java目录下新建四个包文件，分别为com.kevin.action, com.kevin.dao, com.kevin.entity, com.kevin.service, com.kevin.util; 建议方式为右击src/main/java目录--->New---->Package---->（输入）com.kevin.action；这四个包文件主要是用来存放我们的java文件，其中com.kevin.entity用来存放数据库映射对象文件，com.kevin.dao用来存放dao文件（data access object）,com.kevin.service用来存放service文件（服务类文件），com.kevin.action用来存放action文件（供struts2调用）；这了更好地理解这个目录结构，这里补充一下entity, dao ,service, action之间的关系

        2.1.1）entity是hibernate对于数据库表抽象出来的类，它和数据库中的表是完全对应的；

        2.1.2）dao类是针对数据库进行直接操作（调用entity）；

        2.1.3）service是业务逻辑层（通过调用dao层类来进行修改数据库数据）；

        2.1.4）action是表示层，控制页面的跳转（负责调用业务逻辑的服务组件）；

具体可以参考 链接

    2.2）在src/main目录下建立一个webapp目录， 在webapp目录下建立一个WEB-INF目录，在WEB-INF目录再建立web.xml文件，然后在webapp目录下建立 css， image, js目录，再建立index.jsp文件；这个目录就是我们的tomcat目录了；

如下是我们的整体的目录结构

  

三. 修改maven的pom.xml

直接修改pom.xml文件，内容如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.eli</groupId>
    <artifactId>sshTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>3.1.1.RELEASE</spring.version>
        <hibernate.version>3.6.5.Final</hibernate.version>
        <struts2.version>2.3.1</struts2.version>
    </properties>

    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</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-context</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>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>2.1_3</version>
        </dependency>


        <!-- hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <!-- struts2 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <!--config-browser-plugin插件，使用了这个插件之后，就可以很方便的浏览项目中的所有action及其与 jsp view的映射 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-junit-plugin</artifactId>
            <version>${struts2.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>

        <!-- 添加对数据源的支持 -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <webResources>
                        <resource>
                            <directory>src\main\webapp</directory>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
        </plugins>
        <finalName>com</finalName>
    </build>
</project>

四. Java代码层面

1）Entity层

1.1）先建立一个Database，位置在IDEA界面的右面点击Database---->点击界面的加号------->Data Source

-----> Mysql---->根据自己的情况进行配置，相关截图如下：

这里补充一点，就是在建立自己的 Oracle 的时候，一定要点击里面的 Test Connection,确认自己的配置是正确的；

    其中 Name 不用管(任意)，Host 是数据库的主机名，SID 、User、Password 可在你要使用的数据库中查看，查看方法如下：

    打开 SQL Developer —— 右键查看的数据库 —— 属性 —— 左边选中要查看的数据库(system-orcl) —— 右面显示的是数据库信息，其中 SID 就是 IDEA 连接时使用的 SID

 

1.2）操作 Persistence，自动生成 Entity；我们可以看到在 Idea 界面里面看不到 Persistence 选项（将鼠标悬浮在左下角的正方形那里，截图如下）

    因为一开始使用 maven 来搭建项目，我们并没有显示引入 hibernate，所以没有 Persistence 界面，所以我们作如

下操作来显示加入 Hibernate;  点击 File -----> Project Structure ------> Modules -----> 点击+ -------->

选择 Hibernate(如果此处没有 Hibernate 选项，到 File —— Settings —— Plugins —— Hibernate Support

后面的框勾选 —— 重启后就可以了) ------> Apply ------>OK; 看界面，我们可以看到 Persistence 出现了，

    截图如下：

1.3）配置 applicationContext.xml，applicationContext.xml 是 spring 的配置文件，因为在这个项目中我们需要让 spring 接管 Hibernate 的配置工作，所以我们直接建立 applicationContext.xml 文件并配置数据库信息， 为了方便数据库信息的管理，我们同时建立 db.properties。所以我们的操作是在 src/main/resources 下面建立两个文件，一个是 applicationContext.xml，一个是 db.properties; 

    1.3.1) db.properties文件内容如下（是 Oracle 数据库的配置信息）

database.database=oracle
database.driverClassName=oracle.jdbc.driver.OracleDriver
database.username=xxx
database.password=xxx
database.show_sql=true
database.url=jdbc:oracle:thin:@localhost:1521:orcl

    1.3.2）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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 引入数据库配置文件 db.properties -->
<context:property-placeholder location="classpath:db.properties" />
<!--<bean id="placeholderConfig"
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
        <value>classpath:db.properties</value>
    </property>
</bean>-->

<!-- 使用annotation -->
<context:annotation-config/>
<!-- 使用annotation自动注册bean,并检查@Controller, @Service, @Repository注解已被注入 -->
<context:component-scan base-package="cn.eli.action"/>
<context:component-scan base-package="cn.eli.service"/>
<context:component-scan base-package="cn.eli.dao" />

<!-- data connection setting -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${database.driverClassName}"></property>
    <property name="jdbcUrl" value="${database.url}"></property>
    <property name="user" value="${database.username}"></property>
    <property name="password" value="${database.password}"></property>
    <!-- 设置数据库连接池的最大连接数 -->
    <property name="maxPoolSize">
        <value>50</value>
    </property>
    <!-- 设置数据库连接池的最小连接数 -->
    <property name="minPoolSize">
        <value>5</value>
    </property>
    <!-- 设置数据库连接池的初始化连接数 -->
    <property name="initialPoolSize">
        <value>5</value>
    </property>
    <!-- 设置数据库连接池的连接最大空闲时间 -->
    <property name="maxIdleTime">
        <value>20</value>
    </property>
    <!-- c3p0缓存Statement的数量数 -->
    <property name="maxStatements">
        <value>50</value>
    </property>
    <!-- 当连接池里面的连接用完的时候,C3P0一下获取新的连接数 -->
    <property name="acquireIncrement">
        <value>20</value>
    </property>

</bean>

<!-- hibernate 管理-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <!-- 引用上面设置的数据源 -->
    <property name="dataSource">
        <ref bean="dataSource" />
    </property>

    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
            <prop key="hibernate.autoReconnect">true</prop>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
            <!-- 解决session关闭问题 -->
            <prop key="hibernate.enable_lazy_load_no_trans">true</prop>
            <prop key="current_session_context_class">thread</prop>

            <prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
            <prop key="hibernate.max_fetch_depth">3</prop>
            <prop key="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:orcl</prop>
            <prop key="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</prop>
        </props>

    </property>

    <!-- 包扫描的方式加载注解类 -->
    <property name="packagesToScan">
        <list>
            <value>cn.eli.entity</value>
        </list>
    </property>
</bean>

<!-- 用注解来实现事物管理 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>
</beans>

    上面是这个项目完成的pom.xml文件，在这一步主要要配置的是 dataSource 这个 bean 和 sessionFactory 这个bean 这里有一个要注意的，我们刚建立 applicationContext.xml 的时候，会在编辑界面出现一个黄条，如下

    这个时候我们要点击“Configure application context”然后编辑，apply

    注1：如果在上面的操作中找不到黄条，并且无法看到下面的sessionFactory文件，不要急接着往下看，注2

1.4) 生成 Entity 类；这个时候，如果上面正确的话,点击 Persistence，会出现如下的界面：

       

    我们右击sessionFactory--->Generate Persistence Mapping----> By Database Schema; 在Import Database Schema界面进行如下的选择：

         

    成功的话，可看我们src/main/java/com/kevin/entity下面应该有一个User类

    注2：我在这里使用 Persistence 生成实体类，始终创建不了，因为没有sessionFactory文件，

    在创建时缺少 Add to Session Factory

我的办法是创建一个 hibernate.cfg.xml，操作如下

就会生成相应的实体类，实体类生成后将 hibernate.cfg.xml 文件删除即可

2） DAO层代码

      为了代码的可拓展性，我们把实现与定义分离；在src/main/java/com/kevin/dao下面再建立一个impl包，存放接口的实现类；在dao目录下新建一个UserDao.java接口类（记住是接口，在选择类型的时候要选择接口）， 在impl放这个接口的实现类，UserDaoImpl.java

        UserDao.java文件内容

[java]  view plain  copy

1. package com.kevin.dao;  
2.   
3. import com.kevin.entity.User;  
4.   
5. import java.util.List;  
6.   
7. /** 
8.  * Created by kinthon on 17-6-23. 
9.  */  
10. public interface UserDao {  
11.     /** 
12.      * 添加并保存用户 
13.      * @param user 
14.      */  
15.     public void add(User user);  
16.   
17.     /** 
18.      * 进行登录 
19.      */  
20.     public boolean login(User user);  
21.   
22.   
23.     /** 
24.      * 获取用户列表 
25.      */  
26.     public List getUser();  
27.   
28.     /** 
29.      * 根据用户Id获取用户信息 
30.      * @param id 
31.      * @return 
32.      */  
33.     public User getUser(int id);  
34.   
35.     /** 
36.      * 更新用户信息 
37.      * @param user 
38.      */  
39.     public void update(User user);  
40.   
41.   
42.     /** 
43.      * 根据用户id删除用户信息 
44.      * @param id 
45.      */  
46.     public void delete(int id);  
47.   
48. }  

        UserDaoImpl.java 内容

[java]  view plain  copy

1. package com.kevin.dao.impl;  
2.   
3. import com.kevin.dao.UserDao;  
4. import com.kevin.entity.User;  
5. import org.hibernate.Query;  
6. import org.hibernate.SessionFactory;  
7. import org.springframework.stereotype.Repository;  
8. import org.springframework.transaction.annotation.Transactional;  
9.   
10. import javax.annotation.Resource;  
11. import java.util.Iterator;  
12. import java.util.List;  
13.   
14. /** 
15.  * Created by kinthon on 17-6-23. 
16.  */  
17.   
18. @Transactional(rollbackFor = Exception.class)  
19. //出现Exception异常回滚  
20. @Repository("userDao") //进行注入  
21. public class UserDaoImpl implements UserDao {  
22.     @Resource(name="sessionFactory")  
23.     private SessionFactory sessionFactory;  
24.   
25.     @Override  
26.     public void add(User user) {  
27.         sessionFactory.getCurrentSession().save(user);  
28.     }  
29.   
30.     @Override  
31.     public boolean login(User user) {  
32.         Iterator<User> it;  
33.         String hsql="FROM User u where u.username=? and u.password=?";  
34.         System.out.println(hsql);  
35.         Query query = sessionFactory.getCurrentSession().createQuery(hsql);  
36.         query.setString(0, user.getUsername());  
37.         query.setString(1, user.getPassword());  
38.         System.out.println(user.getUsername());  
39.         it=query.iterate();  
40.         if(it.hasNext()) {  
41.             System.out.println("true");  
42.             return true;  
43.         } else {  
44.             System.out.println("false");  
45.             return false;  
46.         }  
47.     }  
48.   
49.     @Override  
50.     public List getUser() {  
51.         return sessionFactory.getCurrentSession().createQuery("FROM User").list();  
52.     }  
53.   
54.     @Override  
55.     public User getUser(int id) {  
56.         return (User)sessionFactory.getCurrentSession().get(User.class, id);  
57.     }  
58.   
59.     @Override  
60.     public void update(User user) {  
61.         sessionFactory.getCurrentSession().update(user);  
62.     }  
63.   
64.     @Override  
65.     public void delete(int id) {  
66.         sessionFactory.getCurrentSession().delete(  
67.                 sessionFactory.getCurrentSession().get(User.class, id)  
68.         );  
69.     }  
70. }  

3） Service层代码

       与DAO层一样，在src/main/java/com/kevin/service下面再建立一个impl包，存放接口的实现类；在service目录下新建一个UserService.java接口类（记住是接口，在选择类型的时候要选择接口）， 在impl放这个接口的实现类，UserServiceImpl.java

       UserService.java 内容

[java]  view plain  copy

1. package com.kevin.service;  
2.   
3. import com.kevin.entity.User;  
4.   
5. import java.util.List;  
6.   
7. /** 
8.  * Created by kinthon on 17-6-23. 
9.  */  
10. public interface UserService {  
11.     public boolean addUser(User user);  
12.   
13.     public boolean login(User user);  
14.   
15.     public List getAllUser();  
16.   
17.     public User getUserById(int id);  
18.   
19.     public boolean updateUser(User user);  
20.   
21.     public boolean deleteUser(int id);  
22. }  

         UserServiceImpl.java 内容

[java]  view plain  copy

1. package com.kevin.service.impl;  
2.   
3. import com.kevin.dao.UserDao;  
4. import com.kevin.entity.User;  
5. import com.kevin.service.UserService;  
6. import org.springframework.stereotype.Service;  
7.   
8. import javax.annotation.Resource;  
9. import java.util.List;  
10.   
11. /** 
12.  * Created by kinthon on 17-6-23. 
13.  */  
14. //注入服务  
15. @Service("userService")  
16. public class UserServiceImpl implements UserService{  
17.     //自动注入userDao，也可以使用@Autowired  
18.     @Resource  
19.     private UserDao userDao;  
20.   
21.   
22.     @Override  
23.     public boolean addUser(User user) {  
24.         this.userDao.add(user);  
25.         return true;  
26.     }  
27.   
28.     @Override  
29.     public boolean login(User user) {  
30.         return this.userDao.login(user);  
31.     }  
32.   
33.     @Override  
34.     public List getAllUser() {  
35.         return this.userDao.getUser();  
36.     }  
37.   
38.     @Override  
39.     public User getUserById(int id) {  
40.         return this.userDao.getUser(id);  
41.     }  
42.   
43.     @Override  
44.     public boolean updateUser(User user) {  
45.         this.userDao.update(user);  
46.         return true;  
47.   
48.     }  
49.   
50.     @Override  
51.     public boolean deleteUser(int id) {  
52.         this.userDao.delete(id);  
53.         return true;  
54.     }  
55. }  

4）Action层

Action主要是调用业务逻辑，结合struts.xml来进行处理页面跳转，我们是希望实现用户登录，在action包下建立一个UserAction.java，代码如下

[java]  view plain  copy

1. package com.kevin.action;  
2.   
3. import com.kevin.entity.User;  
4. import com.kevin.service.UserService;  
5. import com.opensymphony.xwork2.ActionContext;  
6. import com.opensymphony.xwork2.ActionSupport;  
7. import org.springframework.context.annotation.Scope;  
8. import org.springframework.stereotype.Controller;  
9.   
10. import javax.annotation.Resource;  
11. import java.util.Map;  
12.   
13. /** 
14.  * Created by kinthon on 17-6-25. 
15.  */  
16.   
17. @Controller("userAction")  
18. @Scope("prototype")  
19. public class UserAction extends ActionSupport {  
20.     @Resource  
21.     private UserService userService;  
22.   
23.     private User user;  
24.   
25.     public User getUser() {  
26.         return user;  
27.     }  
28.   
29.     public void setUser(User user) {  
30.         this.user = user;  
31.     }  
32.   
33.     public String login() {  
34.         if(userService.login(user)) {  
35.             Map session = ActionContext.getContext().getSession();  
36.             session.put("user", user);  
37.             return SUCCESS;  
38.         } else {  
39.             return ERROR;  
40.         }  
41.     }  
42.   
43. }  

五.  页面代码层面

1）接下来我们要引入struts2， 首先还是在src/main/java/resources/下面建立一个struts.xml文件，内容如下:

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2.   
3. <!DOCTYPE struts PUBLIC  
4.         "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"  
5.         "http://struts.apache.org/dtds/struts-2.3.dtd">  
6.   
7. <struts>  
8.   
9.     <constant name="struts.devMode" value="false"/>  
10.     <constant name="struts.objectFactory" value="spring" />  
11.   
12.     <package name="user" namespace="/" extends="struts-default">  
13.   
14.         <action name="user_*" class="userAction" method="{1}">  
15.             <result name="success">/success.jsp</result>  
16.             <result name="error">/error.jsp</result>  
17.         </action>  
18.   
19.     </package>  
20. </struts>  

2) 配置web.xml，内容如下

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"  
5.          version="3.1">  
6.     <!-- struts2容器控制器 -->  
7.     <filter>  
8.         <filter-name>struts2</filter-name>  
9.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
10.     </filter>  
11.   
12.     <filter-mapping>  
13.         <filter-name>struts2</filter-name>  
14.         <url-pattern>/*</url-pattern>  
15.     </filter-mapping>  
16.     <!-- spring容器配置 -->  
17.     <context-param>  
18.         <param-name>contextConfigLocation</param-name>  
19.         <param-value>/WEB-INF/classes/applicationContext.xml</param-value>  
20.     </context-param>  
21.   
22.      <!-- spring容器监听器 -->  
23.     <listener>  
24.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
25.     </listener>  
26.     <listener>  
27.         <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
28.     </listener>  
29.     <!-- 欢迎页面 -->  
30.     <welcome-file-list>  
31.         <welcome-file>index.jsp</welcome-file>  
32.     </welcome-file-list>  
33.   
34. </web-app>  

加入三个页面 index.jsp（登录页面）, error.jsp（登录失败页面）, success.jsp（登录成功页面）

       index.jsp

[html]  view plain  copy

1. <%--  
2.   Created by IntelliJ IDEA.  
3.   User: kinthon  
4.   Date: 17-6-23  
5.   Time: 下午8:15  
6.   To change this template use File | Settings | File Templates.  
7. --%>  
8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>  
9. <html>  
10. <head>  
11.     <title>Title</title>  
12. </head>  
13. <body>  
14.     <form action="user_login.action" method="post">  
15.         <input type="text" name="user.username" placeholder="输入用户名" />  
16.         <br/>  
17.         <input type="password" name="user.password" placeholder="输入密码" />  
18.         <br />  
19.         <input type="submit" value="登录">  
20.         <input type="reset" value="重置">  
21.     </form>  
22. </body>  
23. </html>  

        success.jsp

[html]  view plain  copy

1. <%--  
2.   Created by IntelliJ IDEA.  
3.   User: kinthon  
4.   Date: 17-6-25  
5.   Time: 下午1:32  
6.   To change this template use File | Settings | File Templates.  
7. --%>  
8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>  
9. <html>  
10. <head>  
11.     <title>success</title>  
12. </head>  
13. <body>  
14.     <h1>hello ${user.username}</h1>  
15. </body>  
16. </html>  

        error.jsp

[html]  view plain  copy

1. <%--  
2.   Created by IntelliJ IDEA.  
3.   User: kinthon  
4.   Date: 17-6-25  
5.   Time: 下午1:32  
6.   To change this template use File | Settings | File Templates.  
7. --%>  
8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>  
9. <html>  
10. <head>  
11.     <title>Title</title>  
12. </head>  
13. <body>  
14.     <h1>somethin error</h1>  
15. </body>  
16. </html>  

五，建立Tomcat服务器

到目前为止，我们已经把所有的代码和配置都完成了，接下来就是加入Tomcat服务器，让我们的程序运行起来；我们直接加入tomcat服务器，操作如图（这个的具体位置在整个界面的右上方），将鼠标悬浮在倒三角形上，会出现为“Edit Configurations...” 点击它然后在打开界面左上角中点击加号选择Tomcat Server---->Local; 点击Apply; 相关操作如下 

       

       

我们试着运行下，运行点击如图：

       

发现服务器启动正常，但是页面不可获取；

我们查看下根目录下的target目录，我们可以看到这个目录没有导出我们webapp里面的文件，这是因为我们还没有进行导出配置；我们进行如下操作，点击File----->Project Strutcture--->Artifacts----->点击+----->web application:Explored ----> From module---->OK; 同时为了让所有的代码都在同一个目录下，我们修改打开的页面的Output directory的目录为对应目录下sshLearningLogin/target;(在本机运行时，有时设置了输出目录为target但是还是会产生不对应的情况，可以更换输出目录为sshLearningLogin/target/out) 相关操作截图和结果图如下：

        

        

    接着回到我们的 tomcat 配置界面，点击界面的右下角fix-->Apply

       

    接着删除之前生成的target目录，重新运行服务器，可以看到如下的：

     

    

    

    

    

-------------------------------------------------------------------------------------------------------------------------------

下面贴一下我遇到的所有问题和解决办法

一、使用 IDEA 连接 ORACLE 的问题
    1.SID 是什么：打开 SQL Developer —— 右键查看的数据库 —— 属性 —— 左边选中要查看的数据库(system-orcl) —— 右面显示的是数据库信息，其中 SID 就是 IDEA 连接时使用的 SID


二、在 IDEA 中的 Project Structure 中没找到 Hibernate
    File —— Settings —— Plugins —— Hibernate Support 后面的框勾选 —— 重启后就可以了


三、使用 Persistence 生成实体类
    sessionFactory 我没看到，我使用的是 hibernate.cfg.xml 创建


四、问题汇总：
1.IOException parsing XML document from ServletContext resource [/WEB-INF/classes/applicationContext.xml];
答：resources 目录下的 aplicationContext.xml 文件名写错了，少了一个 p，应该是：applicationContext.xml


2.com.mchange.v2.c3p0.DriverManagerDataSource.ensureDriverLoaded Could not load driverClass oracle.jdbc.driver.OracleDriver
答：缺少 ojdbc 架包，导入 ojdbc 架包


3.导入 ojdbc 架包不成功
答： http://blog.csdn.net/xiaojinlai123/article/details/79397959 (我是直接将ojdbc.14的包导入到项目中的)


4.Could not open Hibernate Session for transaction; nested exception is org.hibernate.exception.GenericJDBCException: Cannot open connection
答：JDBC架包错误，我用的 ojdbc14.jar 这是以前的数据库架包，需要使用 ojdbc7.jar
注意 JDBC 要注意版本的问题，对于 12c 的数据库要用 12c 的 JDBC 去连接，否则会报错找不到数据库实例的错误或者用户名密码错误。
JDBC的下载地址 http://www.oracle.com/technetwork/database/features/jdbc/jdbc-drivers-12c-download-1958347.html 
注意 ojdbc6.jar 是给 JDK1.6 版本使用的，ojdbc7.jar 是给 JDK1.7 和 1.8 使用的，注意不要下载错了。


5.ELI_USER is not mapped [FROM ELI_USER as u where u.name=? and u.password=?]
答：很明显是查询语句有问题，我的查询语句是这样的
String hsql = "FROM ELI_USER as u where u.name=? and u.password=?";
ELI_USER 是数据库中的表名，出现这个错误的原因就是HQL语句中表名应该是 ORM 映射的类名,而不是你在数据库中的表名，所以将HQL语句中的tab_user的表名改为ORM映射的类名即可。
修改如下：String hsql = "FROM EliUserEntity as u where u.name=? and u.password=?";


6.登录用户名与密码正确，但是还去错误页面
答：调试发现 user.name 是空的，到 index.jsp 中找问题
<input type="text" name="user.username" placeholder="输入用户名"/>
注意这里的 user 一定是 UserAction 中定义的变量名 private EliUserEntity user;
而 username 一定是实体类 EliUserEntity 中的变量名 private String name; 很明显这里的名称是 name 而不是 username，修改如下
<input type="text" name="user.name" placeholder="输入用户名"/>


7.An exception occurred processing [/success.jsp] at line [14]
答：success.jsp 的 14 行是这样的，<h1>hello ${user.username}</h1>，很显示还是 username 的问题，改为 <h1>hello ${user.name}</h1>