maven父子模块，SSH框架整合，登录案例。适合初学者！

最新推荐文章于 2021-01-14 21:05:14 发布

小白阿王

最新推荐文章于 2021-01-14 21:05:14 发布

阅读量149

点赞数

文章标签： java开发框架整合

本文链接：https://blog.csdn.net/weixin_43226447/article/details/84072328

版权

maven父子模块项目整合SSH框架：

本人是初学框架程序员，本篇文章用于自己的积累，有疏忽的地方希望大家包含。也欢迎大家一起探讨，有什么问题大家发现也可以帮我解决一下。先在这里感谢各位了。如果有希望我们大家共同探讨关于java开发的知识，我们也可以一起学习。我的微信留在最下面，下面开始正题：

首先，准备工作及环境如下：

创建maven项目，前提要配置好了maven的环境变量及在 ide 中配置了maven 。
创建父项目，父项目的主要作用是写一些所有项目都能公用的东西，例如需要导入的包。或者是pom文件需要写的东西，这些东西如果每次创造项目都要写一次的话，浪费了很多时间。
创建子项目，我们整合一般利用的都是MVC设计模式，所以我们需要三个子模块，分别为
web层：其包括了视图层（V）和控制层（C）为了展示数据和传入数据到后台此部分我们利用struts2
service层：该层主要做业务逻辑处理。
dao层：数据访问层，利用java代码和数据库之间进行数据持久化操作。
tips : 父模块的packing类型要选择pom
web层的packing类型要选择war
其他两个层选择jar
大概结构如上，架子搭好后开始进入开发步骤：
首先要在父工程导入所需jar包：
由于maven , 所有jar包以pom文件形式写在下面，仅供参考：
本人整合的框架版本分别为 struts2 : 2.3.24 , spring 4.2.4 , hibernate 5.0.7
数据库版本mysql57 , eclipse 用的古老的版本Version: Mars.1 Release (4.5.1)
父项目中，pom文件配置如下：

<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>com.ws</groupId>
  <artifactId>ssh_demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <build>
  	<plugins>
  		<plugin>
  			<groupId>org.apache.maven.plugins</groupId>
  			<artifactId>maven-compiler-plugin</artifactId>
  			<configuration>
  				<source>1.8</source>
  				<target>1.8</target>
  				<encoding>UTF-8</encoding>
  			</configuration>
  		</plugin>
  	</plugins>
  </build>
  <dependencies>
  	<dependency>
  		<groupId>junit</groupId>
  		<artifactId>junit</artifactId>
  		<version>4.9</version>
  		<scope>test</scope>
  	</dependency>
  	<dependency>
  		<groupId>mysql</groupId>
  		<artifactId>mysql-connector-java</artifactId>
  		<version>5.1.21</version>
  		<scope>runtime</scope>
  	</dependency>
  	<dependency>
  		<groupId>javax.servlet</groupId>
  		<artifactId>jsp-api</artifactId>
  		<version>3.0</version>
  		<type>pom.lastUpdated</type>
  		<scope>provided</scope>
  	</dependency>
  	<dependency>
  		<groupId>javax.servlet</groupId>
  		<artifactId>servlet-api</artifactId>
  		<version>3.0</version>
  		<scope>provided</scope>
  	</dependency>
  	<dependency>
		<groupId>org.apache.struts</groupId>
		<artifactId>struts2-core</artifactId>
		<version>2.3.24</version>
		<exclusions>
			<exclusion>
				<artifactId>javassist</artifactId>
				<groupId>javassist</groupId>
			</exclusion>
		</exclusions>
  	</dependency>
	<dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-core</artifactId>
		<version>5.0.7.Final</version>
	</dependency>
	<dependency>
		<groupId>org.apache.struts</groupId>
		<artifactId>struts2-spring-plugin</artifactId>
		<version>2.3.24</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-beans</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-tx</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-orm</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context-support</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-web</artifactId>
		<version>4.2.4.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-api</artifactId>
		<version>1.7.12</version>
	</dependency>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-log4j12</artifactId>
		<version>1.7.12</version>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>c3p0</groupId>
		<artifactId>c3p0</artifactId>
		<version>0.9.1.2</version>
	</dependency>
	<dependency>
		    <groupId>org.aspectj</groupId>
		    <artifactId>aspectjrt</artifactId>
		    <version>1.8.9</version>
	</dependency>
	<dependency>
	    <groupId>aopalliance</groupId>
	    <artifactId>aopalliance</artifactId>
	    <version>1.0</version>
	</dependency>
  </dependencies>
  <modules>
  	<module>ssh_demo_dao</module>
  	<module>ssh_demo_service</module>
  	<module>ssh_demo_web</module>
  </modules>
</project>

tips: 导入jar包时为了避免jar包冲突，我们需要进行一些操作，struts核心包和hibernate核心包都依赖javassist.jar，所以我们需要将版本旧的该包拿掉，在pom文件中利用标签，还有struts2-spring-plugin2.3.24中有一个spring-beans-3.0.5.jar包，而后面我们再引入spring-context.jar包的时候，会再引入一个spring-beans-3.0.5.jar包，像这种情况
下，这两个包不会冲突，而是遵循谁先引入谁生效，谁离我近谁生效的原则（"我"指的是项目）。所以干脆我们自己再重新依赖一个spring-beans-4.2.4.RELEASE进来，保证我们的beans包的高版本。

配置好父模块，我们开始开发dao层：
父子模块结构

我做的是一个登录的小案例

dao层如下：
dao子模块

首先创建pojo包，在包中创建一个类：
代码如下：

package com.oracle.pojo;

import java.io.Serializable;

import org.springframework.stereotype.Component;
@Component
public class Login implements Serializable{
	private static final long serialVersionUID = 1L;
	private Long t_login_id ;
	private String loginname ;
	private String loginpass ;
	public Long getT_login_id() {
		return t_login_id;
	}
	public void setT_login_id(Long t_login_id) {
		this.t_login_id = t_login_id;
	}
	public String getLoginname() {
		return loginname;
	}
	public void setLoginname(String loginname) {
		this.loginname = loginname;
	}
	public String getLoginpass() {
		return loginpass;
	}
	public void setLoginpass(String loginpass) {
		this.loginpass = loginpass;
	}
	@Override
	public String toString() {
		return "Login [t_login_id=" + t_login_id + ", loginname=" + loginname + ", loginpass=" + loginpass + "]";
	}
	public Login(Long t_login_id, String loginname, String loginpass) {
		this.t_login_id = t_login_id;
		this.loginname = loginname;
		this.loginpass = loginpass;
	}
	public Login() {
	}
	
}

因为我数据库中的测试表三个字段，我对应的写了三个属性然后get set方法以及有无参构造以及测试用的toString;
然后我们开始利用Hibernate的ORM，将该类和表映射起来。
对位配置一个loginhiber.hbm.xml
代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping
	PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.oracle.pojo.Login" table="t_login" >
		<id name="t_login_id">
			<generator class="native"></generator>
		</id>
		<property name="loginname" />
		<property name="loginpass" />
	</class>
</hibernate-mapping>

然后写hibernate.cfg.xml ，代码如下：

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	
<hibernate-configuration>
	<session-factory>
		<property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
		<property name="show_sql">true</property>
		<property name="format_sql">true</property>
		<!-- 开启懒加载 -->
		<property name="hibernate.enable_lazy_load_no_trans">true</property>
	</session-factory>
</hibernate-configuration>

然后开始配置applicationContext-dao.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:aop="http://www.springframework.org/schema/aop"
	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/tx
		http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 创造数据源 -->	
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/j245db"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	<!-- 实例化sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
		<property name="mappingLocations" value="classpath:com/oracle/pojo/*.hbm.xml"></property>
	</bean>
	<!-- 实例化loginDao -->
	<bean id="loginDao" class="com.oracle.dao.impl.LoginDaoImpl">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
</beans>

配置好以后我们开始，按照图中结构创建包（接口实现类）接口代码如下：

package com.oracle.dao;

import java.util.List;

import com.oracle.pojo.Login;

public interface LoginDao {
	public List<Login> getUser(String loginname) ;
}

实现类代码如下

package com.oracle.dao.impl;
import java.util.List;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.oracle.dao.LoginDao;
import com.oracle.pojo.Login;
@Repository
public class LoginDaoImpl extends HibernateDaoSupport implements LoginDao{
	@SuppressWarnings("unchecked")
	@Override
	/**
	 * 根据传过来的用户名查出来该用户的全部信息
	 */
	public List<Login> getUser(String loginname) {
		String hql = "from Login where loginname = ?" ;
		List<Login> loginList = (List<Login>)this.getHibernateTemplate().find(hql, loginname) ;
		return loginList;
	}
}

service层结构如下：

service层结构

tips:service层需要获得数据库中传回来的数据，所以要调用dao类的方法，这时就需要我们将写过的dao层打成jar包，导入我们的service层项目中。

导入成功后我们开始构建service层，首先创建三个包，接口实现类还有一个是我写的切面。此类主要对每个参数做一些验证，提高校验效率。

接口代码如下：

package com.oracle.service;
import com.oracle.pojo.Login;
public interface LoginService {
	public boolean getUser(Login login) ;
}

切面类代码如下：

package com.oracle.aspect;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import com.oracle.pojo.Login;
@Component
@Aspect
public class LoginServiceAspect {
	//切点  ： 拦截表达式 拦截LoginServiceImpl类下的getUser方法
	@Pointcut(value="execution(* com.oracle.service.impl.LoginServiceImpl.getUser(..))")
	public void myPointCut(){}
	//环绕通知
	@Around(value="myPointCut()")
	public Object aroundAdvice(ProceedingJoinPoint pjp){
		//获得方法传来的所有参数，因为我们知道该方法穿过来的参数是一个Login类型的 所以我们将其强转为Login类型的
		Object[] args = pjp.getArgs() ;
		Login login = (Login) args[0] ;
		//定义一个返回值 默认为false
		Object result = false ;
		if(login != null){
			String loginpass = login.getLoginpass() ;
			String loginname = login.getLoginname() ;
			//进行非空校验  经过该判断以后我们才认为数据是安全的 然后我们才让其调用连接点
			if(loginpass != null && loginname != null){
				try {
					result = (Boolean) pjp.proceed(args) ;
				} catch (Throwable e) {
					System.out.println("异常通知");
					e.printStackTrace();
				}
			}
		}
		return result ;
	}
}

实现类代码如下：

package com.oracle.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.oracle.dao.LoginDao;
import com.oracle.pojo.Login;
import com.oracle.service.LoginService;
@Service("service")//将我们的service交给spring来替我们管理
public class LoginServiceImpl implements LoginService{
	@Autowired
	private LoginDao dao ;
	
	public boolean getUser(Login login){
		boolean result = false ;
		String loginname = login.getLoginname() ;
		String loginpass = login.getLoginpass() ;
		System.out.println(loginpass);
		List<Login> userList = dao.getUser(loginname) ;
		if(!userList.isEmpty()){
			Login user = userList.get(0) ;
			String userpass = user.getLoginpass() ;
			if(loginpass.equals(userpass)){
				result = true ;
			}
		}
		return result ;
	}
}

然后我们开始配置applicationContext-service.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:aop="http://www.springframework.org/schema/aop"
		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/tx
			http://www.springframework.org/schema/tx/spring-tx.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context.xsd
			http://www.springframework.org/schema/aop
			http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!--事物管理-->
	<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>
	<!--通知管理-->
	<tx:advice id="advice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="create*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
			<tx:method name="update*" propagation="REQUIRED"/>
			<tx:method name="*" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<!-- 包扫描 -->
	<context:component-scan base-package="com.oracle.service"></context:component-scan>
	<context:component-scan base-package="com.oracle.aspect"></context:component-scan>
	<!--切面管理-->
	<aop:aspectj-autoproxy />
	<aop:config>	
	<aop:pointcut expression="execution(* com.oralce.service..*.*(..))" id="myPointCut" />
	<aop:advisor advice-ref="advice" pointcut-ref="myPointCut"/>
	<aop:aspect ref="loginServiceAspect" >
		<aop:around method="aroundAdvice" pointcut-ref="myPointCut" />
	</aop:aspect>
	</aop:config>
	<!-- 仅供测试 整合后去掉 读取该xml中的元素，因为我们需要其中的sessionFactory Bean-->
	<import resource="classpath:applicationContext-dao.xml"/>
</beans>

配置完后，开始测试 , 测试成功后我们开始进入开发web层
web层大致结构如下：
同理我们也要将service的包封装为Jar包，然后在web层进行导入

web层结构

因为我们利用到了struts2的技术，所以我们先创建一个action 
代码如下：

package com.oracle.action;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionSupport;
import com.oracle.pojo.Login;
import com.oracle.service.LoginService;
@Controller//将我们的action交给spring管理
public class LoginAction extends ActionSupport{
	private static final long serialVersionUID = 1L;
	@Autowired
	private LoginService service ;
	private Login login ;
	public String execute() {
		boolean user = service.getUser(login) ;//调用service方法开始进行密码验证
		if(user){	//如果验证成功，返回success 去到成功页面
			return SUCCESS ;
		}
		return ERROR ; //验证失败 返回error 重定向到登录页面
	}
	public Login getLogin() {
		return login;
	}
	public void setLogin(Login login) {
		this.login = login;
	}
}

action创建好之后我们开始配置struts.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
	<package name="p1" namespace="/" extends="struts-default">
		<action name="loginAction" class="com.oracle.action.LoginAction" >
			<result name="success">/jsp/main.jsp</result>
			<result name="error" type="redirect">/login.jsp</result>
		</action>
	</package>
</struts>

配置好sturts.xml 之后，我们开始写前段页面。前端页面就不展示了，就是一个表单，两个input 注意表单路径要写正确然后随便写个main页面成功了跳到main页面失败了打回login页面

然后我们配置web.xml ，将spring 、 hibernate 、struts2 整合到一起。

<?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" id="WebApp_ID" version="3.0">
  <display-name>ssh_template</display-name>
  <!-- 设置主页 -->
  <welcome-file-list>
    <welcome-file>login.jsp</welcome-file>
  </welcome-file-list>
  <!-- 利用通配符的方式读取所有的classpath下的 所有的符合applicationContext的xml文件  -->
  <context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath*:applicationContext-*.xml</param-value>
  </context-param>
  <!-- 配置struts的过滤器，当有请求的时候我们进入到struts2的过滤器中 然后过滤器开始读取struts.xml文件 -->
  <!-- 版本不同过滤器不同 -->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- spring监听 -->
  <listener>
    	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 将spring和hibernate进行连接整合到一起的过滤器 -->
  <filter>
	<filter-name>openSessionInView</filter-name>
	<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
  </filter>
  <filter-mapping>
	<filter-name>openSessionInView</filter-name>
	<url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

配置好web.xml后，我们开始进行简单的测试。

首先将父项目右键，run as install 将所有的项目都打成包测试工具：tomcat7 谷歌浏览器

然后将我们的web项目部署到tomcat服务器中开始运行tomcat 注意观察控制台是否出现异常

无误后，我们在地址栏中输入localhost:8080/web模块的项目名，因为我们设置了主页所以只接输入就可以

这时我们可以看到我们写的登录页面，然后我们输入正确的帐号密码可以进入到main页面
如果输入错误的重定向回到登录页面。

总结：
ssh 框架对于很多方面来讲方便了我们的使用，降低了代码的耦合度，有很多我们不爱做的事情spring都帮我们做了。我们要考虑到的因素就少了很多，但是对sql的优化就不是那么容易实现，如果数据特别大的话，就没有办法在对sql进行优化来提升速度。最后感谢一起观看本篇文章的小伙伴们。你们辛苦了哦！欢迎转发！
本人VX：869475999

小白阿王

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
maven父子模块，SSH框架整合，登录案例。适合初学者！

maven父子模块项目整合SSH框架：首先，准备工作及环境如下：创建maven项目，前提要配置好了maven的环境变量及在 ide 中配置了maven 。创建父项目，父项目的主要作用是写一些所有项目都能公用的东西，例如需要导入的包。或者是pom文件需要写的东西，这些东西如果每次创造项目都要写一次的话，浪费了很多时间。创建子项目，我们整合一般利用的都是MVC设计模式，所以我们需要三个子模块...
复制链接

扫一扫