JavaEE实验八
2021/2022(1)

   实验八 spring-proj1

学生姓名 张坤
学生学号 201906061726
学生班级 软件工程1903
任课教师 韩珊珊
提交日期 2021年10月30日

计算机科学与技术学院

一、基础实验——Spring 框架搭建

实验内容及步骤

创建普通的maven项目

pom.xml中导入maven包

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.8</version>
        </dependency>

spring架构搭建

在spring-prj1 中新建cn.edu.zjut.dao 包，并在其中创建ICustomerDAO 接口定义数据持久层的操作，以及实现类CustomerDAO 实现数据持久层的操作，具体代码如下

package cn.edu.zjut.dao;
public interface ICustomerDAO {
    public void save();
}

package cn.edu.zjut.dao;
public class CustomerDAO implements ICustomerDAO{
    public CustomerDAO(){
        System.out.println("create CustomerDao.");
    }
    @Override
    public void save() {
        System.out.println("execute --save()-- method.");
    }
}

在spring-prj1 中的resource文件夹下创建Spring 配置文件applicationContext.xml，并在其中配置CustomerDAO 实例，具体代码如下：

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <bean id="userDAO" class="cn.edu.zjut.dao.CustomerDAO" />
</beans>

在spring-prj1 中新建cn.edu.zjut.app 包，并在其中创建测试类SpringEnvTest，调用CustomerDAO 实例的save()方法，具体代码如下：

package cn.edu.zjut.app;
import cn.edu.zjut.dao.ICustomerDAO;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @Author: 张坤
 * @DateTime: 2021/11/22 10:12
 * @Description: 该类用于 TODO
 */
public class SpringEnvTest {
    public static void main(String[] args) {
    //创建Spring 容器
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取CustomerDAO 实例
    ICustomerDAO userDao = (ICustomerDAO) ctx.getBean("userDAO");
        userDao.save();
    }
}

输出如下

注册逻辑实现

在spring-prj1 中新建cn.edu.zjut.service 包，并在其中创建IUserService 接口定义注册逻辑，以及实现类UserService 实现注册逻辑，具体代码如下

package cn.edu.zjut.service;
public interface IUserService {
    public void register();
}

package cn.edu.zjut.service;
public class UserService implements IUserService{
    private ICustomerDAO customerDAO = null;
    public UserService(){
        System.out.println("create UserService.");
    }
    public void setCustomerDAO(ICustomerDAO customerDAO) {
        System.out.println("--setCustomerDAO--");
        this.customerDAO = customerDAO;
    }
    public void register() {
        System.out.println("execute --register()-- method.");
        customerDAO.save();
    }
}

修改Spring 配置文件applicationContext.xml，在其中增加UserService 实例的配置，具体代码如下：

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <bean id="userDAO" class="cn.edu.zjut.dao.CustomerDAO" />
    <bean id="userService" class="cn.edu.zjut.service.UserService">
        <property name="customerDAO" ref="userDAO" />
    </bean>
</beans>

修改测试类SpringEnvTest，调用UserService 实例的register()方法，具体代码如下：

public class SpringEnvTest {
    public static void main(String[] args) {
        //创建Spring 容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取UserService 实例
        IUserService userService =
                (IUserService) ctx.getBean("userService");
        userService.register();
    }
}

运行如下

实验总结

1. 运行结果截图；
2. 根据实验过程，观察运行后的控制台输出，查找相关资料，总结Spring 容器管理Bean 组件的过程（如：何时加载、何时调用Bean 实例中的方法等）以及进行依赖注入的过程，并记录下来；

• 加载过程：
  1. 利用 EncodedResource 二次包装资源文件
  2. 获取资源输入流，并构造 InputSource 对象
  3. 获取 XML 文件的实体解析器和验证模式
  4. 加载 XML 文件，获取对应的 Document 对象
  5. 由 Document 对象解析并注册 bean
• 实例化：
  当spring容器实例化的时候，把容器中对象全部完成实例化
• 依赖注入过程：
  依赖注入的过程是“用户第一次向IoC容器索要Bean时触发的”。BeanFactory进行索要，索要的方法就BeanFactory定义的getBean()接口。调用这个接口，就等于触发依赖注入了

1. 根据实验步骤4、8，查找相关资料，总结Spring 配置文件中bean 元素及其属性、子元素的作用，并记录下来；

一、bean标签的属性
1）scope：用来配置spring bean的作用域
2）singleton：表示bean为单例的
3）abstract：设置为true，将该bean仅仅作为模板使用，应用程序上下文不会试图预先初始化它
4）lazy-init：设为true，延迟加载，该bean不会在ApplicationContext启动时提前被实例化，而是第一次向容器通过getBean索取bean时实例化
注：只对singleton的bean起作用
5）autowire：自动装配
6）dependency-check：依赖检查
7）depends-on：表示一个bean的实例化依靠另一个bean先实例化
8）autowire-candidate：设为false，容器在查找自动装配对象时，将不考虑该bean，即它不会被考虑作为其他bean自动装配的候选者，但是该bean本身可以使用自动装配来注入其他bean
9）primary：该bean优先被注入
10）init-method：初始化bean时调用的方法
11）destory-method：容器销毁之前所调用的方法
12）factory-method：当调用factory-method所指向的方法时，才开始实例化bean
13）factory-bean：调用静态工厂方法的方式创建bean
二、bean的子元素
1）meta：元数据，当需要使用里面的信息时可以通过key获取
2）lookup-method：获取器注入，是把一个方法声明为返回某种类型的bean但实际要返回的bean是在配置文件里面配置的
3）replaced-method：可以在运行时调用新的方法替换现有的方法，还能动态的更新原有方法的逻辑
4）constructor-arg：对bean自动寻找对应的构造函数，并在初始化的时候将设置的参数传入进去
5）property：基本数据类型赋值
6）qualifier：通过Qualifier指定注入bean的名称

1. 根据实验步骤5、9，查找相关资料，总结控制反转模式下两个Java 实例的依赖关系与传统的程序设计过程体现出的依赖关系由什么区别，控制反转的优点是什么，并记录下来；

• 依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。
• 优点：便于更换子类

1. 碰到的问题及解决方案或思考；
2. 实验收获及总结。

   二、提高实验——Spring 与Hibernate 的整合

   实验内容及步骤

   数据库创建

   ```sql create table customer ( customerID int not null

    primary key,

   Account varchar(20) null, Password varchar(20) null, Name varchar(20) null, Sex tinyint null, Birthday date null, Phone varchar(20) null, Email varchar(100) null, Address varchar(200) null, Zipcode varchar(10) null, Fax varchar(20) null );

INSERT INTO hibernatedb.customer (customerID, Account, Password, Name, Sex, Birthday, Phone, Email, Address, Zipcode, Fax) VALUES (1, ‘zjut’, ‘Zjut’, null, null, null, null, null, null, null, null); INSERT INTO hibernatedb.customer (customerID, Account, Password, Name, Sex, Birthday, Phone, Email, Address, Zipcode, Fax) VALUES (2, ‘admin’, ‘Admin’, null, null, null, null, null, null, null, null); INSERT INTO hibernatedb.customer (customerID, Account, Password, Name, Sex, Birthday, Phone, Email, Address, Zipcode, Fax) VALUES (3, ‘temp’, ‘Temp’, null, null, null, null, null, null, null, null);

<a name="FyaAV"></a>
### maven包导入
```xml
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.32.Final</version>
        </dependency>
        <!--    mysql驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>

搭建hibernate框架

在/recourse 中新建配置文件hibernate.cfg.xml，具体代码可参照“实验五Hibernate 基础应用”中基础实验里的hibernate.cfg.xml；

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory name="HibernateSessionFactory">
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/hibernatedb</property>
        <property name="hibernate.connection.username">
            zhangkun</property>
        <property name="hibernate.connection.password">
            zhangkun
        </property>
        <property name="hibernate.dialect">
            org.hibernate.dialect.MySQLDialect</property>
    </session-factory>
</hibernate-configuration>

在hibernate-prj2 中新建cn.edu.zjut.po 包， 并在其中创建持久化类Customer.java 以及Hibernate 映射文件Customer.hbm.xml，具体代码可参照“实验五Hibernate 基础应用”中基础实验里的内容；

@Data
public class Customer implements java.io.Serializable{
    private int customerId;
    private String account; private String password;
    private String name; private Boolean sex;
    private Date birthday; private String phone;
    private String email; private String address;
    private String zipcode; private String fax;
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD
3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="cn.edu.zjut.po.Customer" table="customer"
           catalog="hibernatedb">
        <id name="customerId" type="int">
            <column name="customerID" />
            <generator class="increment" />
        </id>
        <property name="account" type="string">
            <column name="account" length="20" unique="true" />
        </property>
        <property name="password" type="string">
            <column name="password" length="20" />
        </property>
        <property name="name" type="string">
            <column name="name" length="20" />
        </property>
        <property name="sex" type="java.lang.Boolean">
            <column name="sex" />
        </property>
        <property name="birthday" type="date">
            <column name="birthday" length="10" />
        </property>
        <property name="phone" type="string">
            <column name="phone" length="20" />
        </property>
        <property name="email" type="string">
            <column name="email" length="100" />
        </property>
        <property name="address" type="string">
            <column name="address" length="200" />
        </property>
        <property name="zipcode" type="string">
            <column name="zipcode" length="10" />
        </property>
        <property name="fax" type="string">
            <column name="fax" length="20" />
        </property>
    </class>
</hibernate-mapping>

修改配置文件hibernate.cfg.xml，增加Customer.hbm.xml 映射文件的声明；

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory name="HibernateSessionFactory">
        ......
        <mapping resource="/Customer.hbm.xml" />
    </session-factory>
</hibernate-configuration>

在cn.edu.zjut.dao 包中创建数据库操作基础类BaseHibernateDAO.java，具体代码如下

package cn.edu.zjut.dao;
public class BaseHibernateDAO {
    private SessionFactory sessionFactory;
    public Session getSession(){
        return sessionFactory.openSession();
    }
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
}

修改cn.edu.zjut.dao 包中的ICustomerDAO 接口和CustomerDAO 实现类，为save()方法增加一个Customer 类型的输入参数，并使CustomerDAO 继承数据库操作基础类BaseHibernateDAO，具体代码如下：

package cn.edu.zjut.dao;
import cn.edu.zjut.po.Customer;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class CustomerDAO extends BaseHibernateDAO implements ICustomerDAO{
    public CustomerDAO(){
        System.out.println("create CustomerDao.");
    }
    @Override
    public void save(Customer transientInstance) {
        Transaction tran = null;
        Session session = null;
        try {
            session = getSession();
            tran = session.beginTransaction();
            session.save(transientInstance);
            tran.commit();
        } catch (RuntimeException re) {
            if(tran != null) {
                tran.rollback();
            }
            throw re;
        } finally {
            session.close();
        }
    }
}

相应地修改cn.edu.zjut.service 包中的IUserService 接口和UserService 实现类，为register()方法增加一个Customer 类型的输入参数，代码如下

package cn.edu.zjut.service;
public interface IUserService {
    public void register(Customer transientInstance);
}

package cn.edu.zjut.service;
public class UserService implements IUserService{
    private ICustomerDAO customerDAO = null;
    public UserService(){
        System.out.println("create UserService.");
    }
    public void setCustomerDAO(ICustomerDAO customerDAO) {
        System.out.println("--setCustomerDAO--");
        this.customerDAO = customerDAO;
    }
    @Override
    public void register(Customer transientInstance) {
        System.out.println("execute --register()-- method.");
        customerDAO.save(transientInstance);
    }
}

修改Spring 配置文件applicationContext.xml，修改beans 元素的属性，并在其中增加数据源的配置;增加SessionFactory 实例,增加BaseHibernateDAO实例的配置并在其中注入sessionFactory，同时修改CustomerDAO 实例的配置属性的配置，，代码片段如下：

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <bean id="userService" class="cn.edu.zjut.service.UserService">
        <property name="customerDAO" ref="userDAO" />
    </bean>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName"
                  value="com.mysql.cj.jdbc.Driver"/>
        <property name="url"
                  value="jdbc:mysql://localhost:3306/hibernatedb"/>
        <property name="username" value="zhangkun"/>
        <property name="password" value="zhangkun"/>
    </bean>
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLDialect
                </prop>
            </props>
        </property>
        <property name="mappingResources">
            <list>
                <value>/Customer.hbm.xml</value>
            </list>
        </property>
    </bean>
    <bean id="baseDAO" class="cn.edu.zjut.dao.BaseHibernateDAO">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <bean id="userDAO" class="cn.edu.zjut.dao.CustomerDAO"
          parent="baseDAO"/>
</beans>

效果查看

三、扩展实验——Spring、Struts 与Hibernate 的整合

实验内容及步骤

maven包导入

        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.15</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-spring-plugin -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.5.27</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.8</version>
        </dependency>

Struts框架搭建

在spring-prj1 中新建cn.edu.zjut.action 包，并在其中创建UserAction.java，用于调用用户注册逻辑，代码片段如下：

package cn.edu.zjut.action;
import cn.edu.zjut.po.Customer;
import cn.edu.zjut.service.IUserService;
import lombok.Data;
/**
 * @Author: 张坤
 * @DateTime: 2021/11/23 19:32
 * @Description: 该类用于 TODO
 */
@Data
public class UserAction {
    private Customer loginUser;
    private IUserService userService = null;
    public String execute() {
        userService.register(loginUser);
        return "success";
    }
}

修改Spring 配置文件applicationContext.xml，增加对UserAction 实例的配置，代码片段如下：

    <bean id="userAction" class="cn.edu.zjut.action.UserAction"
          scope="prototype">
        <property name="userService" ref="userService" />
    </bean>

在项目的src/路径下创建Struts2 配置文件struts.xml，用于配置Action 并设置页面导航，具体代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts
Configuration 2.1//EN"
        "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
    <package name="strutsBean" extends="struts-default"
             namespace="/">
        <action name="register" class="userAction">
            <result name="success">/regSuccess.jsp</result>
            <result name="fail">/regFail.jsp</result>
        </action>
    </package>
</struts>

在spring-prj1 中新建webapp文件夹

在webapp下新建WEB-INF文件夹,该文件夹下新建web.xml文件编辑Web 应用的web.xml 文件，增加Struts2 核心Filter 的配置，并添加对Spring 监听器的配置，代码片段如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name>Archetype Created Web Application</display-name>
  <welcome-file-list>
    <welcome-file>login.jsp</welcome-file>
  </welcome-file-list>
  <!--   定义Struts2 的核心Filter -->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>
      org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
    </filter-class>
  </filter>
  <!--   让Struts2 的核心Filter 拦截所有请求-->
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
</web-app>

在webapp文件夹下新建register.jsp 页面， 作为用户注册视图， 新建regiSuccess.jsp 和regFail.jsp 页面，分别作为注册成功和失败的视图；

1. register.jsp

   <%@ taglib prefix="s" uri="/struts-tags" %>
   <%@ taglib prefix="sx" uri="/struts-dojo-tags" %>
   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
   <head>
    <title>Title</title>
    <sx:head/>
   </head>
   <body>
   <s:form action="register" method="post">
    <s:textfield name="loginUser.account" label="请输入用户名"/>
    <s:textfield name="loginUser.name" label="请输入用户名"/>
    <s:password name="loginUser.password" label="请输入密码"/>
    <%--    <s:password name="loginUser.repassword" label="请再次输入密码"/>--%>
    <s:radio name="loginUser.sex" list="#{1 : '男', 0 : '女'}" label
            ="请输入性别"/>
    <sx:datetimepicker name="loginUser.birthday" displayFormat
            ="yyyy-MM-dd" label="请输入生日"/>
    <s:textfield name="loginUser.phone" label="请输入电话"/>
    <s:textfield name="loginUser.email" label="请输入邮箱"/>
    <s:textfield name="loginUser.address" label="请输入联系地址"/>
    <s:textfield name="loginUser.zipcode" label="请输入邮政编码"/>
    <s:textfield name="loginUser.fax" label="请输入传真号码"/>
    <s:submit value="注册"/>
    <s:reset value="重置"/>
   </s:form>
   </body>
   </html>

2. regiSuccess.jsp

   <body>
   注册成功
   </body>

3. regFail.jsp

   <body>
   修改个人信息和删除个人信息失败
   </body>

   查看效果

   点击链接http://localhost:8080/spring_prj1_war_exploded/register.jsp
   查看注册页面
   
   点击注册
   
   查看数据库效果
   

   实验总结

4. 运行结果截图；

5. 结合实验过程，总结Spring 整合Struts2 框架的关键步骤，并记录下来；
6. 根据实验步骤7，总结本实验中的UserAction 与以往实验中的写法关键区别，并记录下来；
7. 根据实验步骤9，查找相关资料，总结配置文件applicationContext.xml 中bean 元素的prototype 属性及其取值的含义，并记录下来；
8. 根据实验步骤11，查找相关资料，总结web.xml 文件中添加监听器的目的，并记录下来；
9. 碰到的问题及解决方案或思考；
10. 实验收获及总结。