idea创建maven项目整合SSH

前言

前面，我们已经通过IDEA直接整合过SSH(spring, Struts, hibernate)，在这个文章中， 我將主要实现如下事件：

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

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

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

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

一. 前期准备

1）环境

        a）安装IDEA

        b）安装mysql

2）数据库

        a）直接使用github上面的SEL.sql文件进行建立数据表和插入信息(主要命令为source SEL.sql)；相关的操作截图如下（执行目录为.sql文件所在目录）：

二. 建立项目

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文件，内容如下

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5.     <modelVersion>4.0.0</modelVersion>  
6.   
7.     <groupId>ssh_learning_login</groupId>  
8.     <artifactId>kevin</artifactId>  
9.     <version>1.0-SNAPSHOT</version>  
10.   
11.     <properties>  
12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
13.         <spring.version>3.1.1.RELEASE</spring.version>  
14.         <hibernate.version>3.6.5.Final</hibernate.version>  
15.         <struts2.version>2.3.1</struts2.version>  
16.     </properties>  
17.   
18.     <dependencies>  
19.         <!-- junit -->  
20.         <dependency>  
21.             <groupId>junit</groupId>  
22.             <artifactId>junit</artifactId>  
23.             <version>3.8.1</version>  
24.             <scope>test</scope>  
25.         </dependency>  
26.   
27.         <!-- spring -->  
28.         <dependency>  
29.             <groupId>org.springframework</groupId>  
30.             <artifactId>spring-core</artifactId>  
31.             <version>${spring.version}</version>  
32.         </dependency>  
33.         <dependency>  
34.             <groupId>org.springframework</groupId>  
35.             <artifactId>spring-context</artifactId>  
36.             <version>${spring.version}</version>  
37.         </dependency>  
38.         <dependency>  
39.             <groupId>org.springframework</groupId>  
40.             <artifactId>spring-jdbc</artifactId>  
41.             <version>${spring.version}</version>  
42.         </dependency>  
43.         <dependency>  
44.             <groupId>org.springframework</groupId>  
45.             <artifactId>spring-beans</artifactId>  
46.             <version>${spring.version}</version>  
47.         </dependency>  
48.         <dependency>  
49.             <groupId>org.springframework</groupId>  
50.             <artifactId>spring-web</artifactId>  
51.             <version>${spring.version}</version>  
52.         </dependency>  
53.         <dependency>  
54.             <groupId>org.springframework</groupId>  
55.             <artifactId>spring-expression</artifactId>  
56.             <version>${spring.version}</version>  
57.         </dependency>  
58.         <dependency>  
59.             <groupId>org.springframework</groupId>  
60.             <artifactId>spring-orm</artifactId>  
61.             <version>${spring.version}</version>  
62.         </dependency>  
63.         <dependency>  
64.             <groupId>cglib</groupId>  
65.             <artifactId>cglib-nodep</artifactId>  
66.             <version>2.1_3</version>  
67.         </dependency>  
68.   
69.   
70.         <!-- hibernate -->  
71.         <dependency>  
72.             <groupId>org.hibernate</groupId>  
73.             <artifactId>hibernate-core</artifactId>  
74.             <version>${hibernate.version}</version>  
75.         </dependency>  
76.   
77.         <!-- struts2 -->  
78.         <dependency>  
79.             <groupId>org.apache.struts</groupId>  
80.             <artifactId>struts2-core</artifactId>  
81.             <version>${struts2.version}</version>  
82.         </dependency>  
83.         <!--config-browser-plugin插件，使用了这个插件之后，就可以很方便的浏览项目中的所有action及其与 jsp view的映射 -->  
84.         <dependency>  
85.             <groupId>org.apache.struts</groupId>  
86.             <artifactId>struts2-junit-plugin</artifactId>  
87.             <version>${struts2.version}</version>  
88.             <scope>test</scope>  
89.         </dependency>  
90.         <dependency>  
91.             <groupId>org.apache.struts</groupId>  
92.             <artifactId>struts2-spring-plugin</artifactId>  
93.             <version>${struts2.version}</version>  
94.         </dependency>  
95.   
96.         <!-- 添加对数据库的支持 -->  
97.         <dependency>  
98.             <groupId>mysql</groupId>  
99.             <artifactId>mysql-connector-java</artifactId>  
100.             <version>5.0.5</version>  
101.         </dependency>  
102.   
103.         <!-- 添加对数据源的支持 -->  
104.         <dependency>  
105.             <groupId>c3p0</groupId>  
106.             <artifactId>c3p0</artifactId>  
107.             <version>0.9.1.2</version>  
108.         </dependency>  
109.   
110.     </dependencies>  
111.     <build>  
112.         <plugins>  
113.             <plugin>  
114.                 <groupId>org.apache.maven.plugins</groupId>  
115.                 <artifactId>maven-war-plugin</artifactId>  
116.                 <version>2.2</version>  
117.                 <configuration>  
118.                     <webResources>  
119.                         <resource>  
120.                             <directory>src\main\webapp</directory>  
121.                         </resource>  
122.                     </webResources>  
123.                 </configuration>  
124.             </plugin>  
125.             <plugin>  
126.                 <groupId>org.apache.maven.plugins</groupId>  
127.                 <artifactId>maven-compiler-plugin</artifactId>  
128.                 <configuration>  
129.                     <source>1.6</source>  
130.                     <target>1.6</target>  
131.                 </configuration>  
132.             </plugin>  
133.         </plugins>  
134.         <finalName>com</finalName>  
135.     </build>  
136. </project>  

四. Java代码层面

1）Entity层

1.1）先建立一个Database，位置在IDEA界面的右面点击Database---->点击界面的加号------->Data Source-----> Mysql---->根据自己的情况进行配置，相关截图如下：

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

        1.2）操作Persistence，自动生成Entity；我们可以看到在Idea界面里面看不到Persistence选项（将鼠标悬浮在左下角的正方形那里，截图如下），因为一开始使用maven来搭建项目，我们并没有显示引入hibernate，所以没有Persistence界面，所以我们作如下操作来显示加入Hibernate;  点击 File-----> Project Structure------>Modules----->点击+-------->选择Hibernate------>Apply------>OK; 看界面，我们可以看到 Persistence出现了，截图如下：

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

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

[plain]  view plain  copy

1. database.database=mysql  
2. database.driverClassName=com.mysql.jdbc.Driver  
3. database.username=root  
4. database.password=XXXX  
5. database.show_sql=true  
6. database.url=jdbc:mysql://localhost:3306/TESTDB?useUnicode=true&characterEncoding=UTF-8  

                  1.3.2）applicationContext.xml内容如下

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"  
5.        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">  
6.     <!-- classpath 是指什么呢 -->  
7.     <context:property-placeholder location="classpath:db.properties" />  
8.   
9.     <!-- 使用annotation -->  
10.     <context:annotation-config/>  
11.     <!-- 使用annotation自动注册bean,并检查@Controller, @Service, @Repository注解已被注入 -->  
12.     <context:component-scan base-package="com.kevin.action"/>  
13.     <context:component-scan base-package="com.kevin.service"/>  
14.     <context:component-scan base-package="com.kevin.dao" />  
15.   
16.     <!-- data connection setting -->  
17.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
18.         <property name="driverClass" value="${database.driverClassName}"></property>  
19.         <property name="jdbcUrl" value="${database.url}"></property>  
20.         <property name="user" value="${database.username}"></property>  
21.         <property name="password" value="${database.password}"></property>  
22.         <!-- 设置数据库连接池的最大连接数 -->  
23.         <property name="maxPoolSize">  
24.             <value>50</value>  
25.         </property>  
26.         <!-- 设置数据库连接池的最小连接数 -->  
27.         <property name="minPoolSize">  
28.             <value>5</value>  
29.         </property>  
30.         <!-- 设置数据库连接池的初始化连接数 -->  
31.         <property name="initialPoolSize">  
32.             <value>5</value>  
33.         </property>  
34.         <!-- 设置数据库连接池的连接最大空闲时间 -->  
35.         <property name="maxIdleTime">  
36.             <value>20</value>  
37.         </property>  
38.         <!-- c3p0缓存Statement的数量数 -->  
39.         <property name="maxStatements">  
40.             <value>50</value>  
41.         </property>  
42.         <!-- 当连接池里面的连接用完的时候,C3P0一下获取新的连接数 -->  
43.         <property name="acquireIncrement">  
44.             <value>20</value>  
45.         </property>  
46.   
47.     </bean>  
48.   
49.     <!-- hibernate 管理-->  
50.     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
51.         <!-- 引用上面设置的数据源 -->  
52.         <property name="dataSource">  
53.             <ref bean="dataSource" />  
54.         </property>  
55.   
56.         <property name="hibernateProperties">  
57.             <props>  
58.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
59.                 <prop key="hibernate.autoReconnect">true</prop>  
60.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
61.                 <prop key="hibernate.show_sql">true</prop>  
62.                 <prop key="hibernate.format_sql">true</prop>  
63.                 <!-- 解决session关闭问题 -->  
64.                 <prop key="hibernate.enable_lazy_load_no_trans">true</prop>  
65.                 <prop key="current_session_context_class">thread</prop>  
66.   
67.                 <prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>  
68.                 <prop key="hibernate.max_fetch_depth">3</prop>  
69.                 <prop key="hibernate.connection.url">jdbc:mysql://localhost:3306/TESTDB</prop>  
70.                 <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>  
71.             </props>  
72.   
73.         </property>  
74.   
75.         <!-- 包扫描的方式加载注解类 -->  
76.         <property name="packagesToScan">  
77.             <list>  
78.                 <value>com.kevin.entity</value>  
79.             </list>  
80.         </property>  
81.     </bean>  
82.   
83.     <!-- 用注解来实现事物管理 -->  
84.     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
85.         <property name="sessionFactory" ref="sessionFactory" />  
86.     </bean>  
87.     <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>  
88. </beans>  

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

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

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

       

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

         

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

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; 相关操作截图和结果图如下：

        

        

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

       

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

     

    

    

    

    

六. 总结

本教程至此结束，如有问题可以直接留言，也可以通过qinkai1994@qq.com进行联系交流