Spring整合Struts2框架以及注解

1 Spring整合Struts2框架

Struts2回顾，如图所示：
1.需要引入: struts2 Spring Struts2-Spring-plugin的代码如下：

<?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>com.txw</groupId>
  <artifactId>spring-04</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <dependencies>
    <!--Spring相关依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <!--Struts2依赖-->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.16.3</version>
    </dependency>
    <!--Struts2整合Spring依赖-->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.3.16.3</version>
    </dependency>
    <!--Servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>spring-04</finalName>
  </build>
</project>

如图所示：

2.在web.xml添加的代码如下：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <!--核心过滤器-->
  <display-name>Archetype Created Web Application</display-name>
  <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>
</web-app>

如图所示：
3.编写UserAction的代码如下：

package com.txw.action;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionSupport;
/**
 * @author Adair
 * E-mail: [email protected]
 */
@SuppressWarnings("all")   // 注解警告信息
public class UserAction  extends ActionSupport {
    
    

    private String name;

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public String findAll(){
    
    
        // 调用业务
        System.out.println("--------Action invoke-----------");
        // 跳转页面
        return Action.SUCCESS;
    }
}

如图所示：
4.编写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="user" extends="struts-default" namespace="/user">
        <action name="findAll" class="com.txw.action.UserAction" method="findAll">
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>

如图所示：
5.使用Tomcat部署运行，通过浏览器访问：http://localhost:8080/user/findAll，如图所示：
7.工厂管理Action组件的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <!--管理action组件-->
    <bean id="userAction" class="com.txw.action.UserAction"></bean>
</beans>

如图所示：

8.修改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="user" extends="struts-default" namespace="/user">
        <!--class:类全限定名 Struts2要通过反射创建action类的对象-->
        <!--现在程序 不需要Struts2创建 向Spring工厂要-->
        <action name="findAll" class="userAction" method="findAll">
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>

如图所示：
注意:``配置文件中书写的是工厂中管理的action的bean的id。
9.修改web.xml的代码如下：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
   <display-name>Archetype Created Web Application</display-name>
  <!--核心过滤器 Struts给服务器一个类 服务器运行，由服务器创建类的对象-->
  <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>

  <!--配置创建工厂监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--初始化参数 在监听器中直接获取 param-name:key 随意  param-value:value-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
</web-app>

如图所示：
10再次访问浏览器，如图所示：
总结，如图所示：

2 Spring的注解式开发

注解: Annotation
注解开发: 为了去提高现有配置文件开发的开发效率。
1.引入的依赖如下：

<?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>com.txw</groupId>
  <artifactId>spring_05</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <dependencies>
    <!--mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
    </dependency>
    <!--spring 4.3.2相关依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <!--mybatis-spring整合jar-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.40</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>spring_05</finalName>
  </build>
</project>

如图所示：
2.编写UserDao的代码如下：

package com.txw.dao;

/**
 * @author Adair
 * E-mail: [email protected]
 */
@SuppressWarnings("all")   // 注解警告信息
public interface UserDao {
    
    

    public void ma();
}

如图所示：
Spring自2.5版本以后提供了一些注解用来在使用spring时进行快速开发,详细如下：

# 1. @Component(value="beanid")
				修饰范围:    用在类上
				注解作用:    通用的创建实例的注解,用来创建当前这个类的实例
				value属性:	用来指定创建的对象在工厂中的唯一标识   如果不指定默认创建对象在工厂中的标识为类名首字母小写
				
# 2. @Repository 
				修饰范围:    用在类上
				注解作用:    @component的子类注解专用于DAO组件的创建,通常加在DAO组件上
				value属性:	用来指定创建的对象在工厂中的唯一标识   如果不指定默认创建对象在工厂中的标识为类名首字母小写

# 3. @Service
				修饰范围:    用在类上
				注解作用:    @component的子类注解专用于Service组件的创建,通常加在Service组件上
				value属性:	用来指定创建的对象在工厂中的唯一标识   如果不指定默认创建对象在工厂中的标识为类名首字母小写

# 4. @Controller
			  修饰范围:    用在类上
				注解作用:    @component的子类注解专用于Action组件的创建,通常加在Action组件上
				value属性:	用来指定创建的对象在工厂中的唯一标识   如果不指定默认创建对象在工厂中的标识为类名首字母小写

3.编写UserDaoImpl的代码如下：

package com.txw.dao.impl;

import com.txw.dao.UserDao;
import org.springframework.stereotype.Component;
/**
 * 
 * @author Adair
 * E-mail: [email protected]
 */
@Component(value = "userDao")
public class UserDaoImpl implements UserDao {
    
    

    @Override
    public void ma() {
    
    
        System.out.println("------ma invoke!---------");
    }
}

如图所示：
4.编写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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--前置设置 通知工厂使用了注解开发
        component-scan:通知工厂扫描注解
         base-package:指定Spring扫描注解的位置
         扫描多个包用逗号隔开  com.txw.dao,com.txw.service,...
    -->
    <context:component-scan base-package="com.txw"/>
</beans>

如图所示：
5…编写SpringTest的代码如下：

package com.txw.test;

import com.txw.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 测试
 * @author Adair
 * E-mail: [email protected]
 */
public class SpringTest {
    
    

    @Test
    public void test1(){
    
    
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        UserDao userDao = (UserDao) context.getBean("userDao");
        userDao.ma();
    }
}

如图所示：
6.控制对象的创建次数的注解

 # 1. @Scope(value="singleton|prototype")
 			  修饰范围:    用在类上
				注解作用:    用来控制这个实例在工厂中的创建次数
				value属性:	singleton为单例,prototype为多例   默认单例

7.注入相关的注解

# 1. @Autowired(Spring提供)
				修饰范围:    用在成员变量或成员变量的GET/SET方法上
				注解作用:		 用来给类中成员变量赋值
				注入原则:    默认根据类型自动注入

# 2. @Resource(JAVAEE提供)
				修饰范围:    用在成员变量或成员变量的GET/SET方法上
				注解作用:		 用来给类中成员变量赋值
				注入原则:    默认根据名称自动注入名称找不到根据类型自动注入

8.控制事务的相关注解

# 1. @Transactional
			  修饰范围:    用在类上主要用在业务层组件类上或者是方法上
				注解作用:		 用来给类中方法加入事务,当类上和方法上同时存在该注解时局部优先
				注解属性:    
							propagation  用来控制传播属性
							Isolation    用来控制隔离级别
							timeout      用来设置超时性
							rollback-for 用来设置什么异常回滚
							norollback-for 用来设置什么异常不会滚
							readonly     用来设置事务读写性

注意:如果要使用事务注解在配置文件中必须开启事务注解生效加入如下配置:

    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3 总结

1.什么是spring框架 谈谈你对spring框架的理解?
IOC DI依赖注入 AOP
描述: 项目接触spring框架 就你的理解 spring框架核心工厂管理项目中很多对象(框架整合时 第三方框架中对象的创建)
工厂提供依赖注入 注入方式 SET 构造方法 自动注入 。
项目接触spring框架 你的理解 spring框架好处提供面向切面编程思想 额外通用功能 作为附加操作 。
配置到项目中那些类中那些方法上 spring事务处理(事务细粒度配置 传播属性 事务隔离级别 …)。
2.spring框架中注入方式有几种? 3种
SET方式注入 语法: 类中必须提供工厂SET方法 比较灵活 原理:创建对象 调用SET方法赋值。
构造注入 语法: 类中必须提供构造方法 构造方法重载… 原理:创建对象同时完成属性赋值操作 强制注入。
自动注入
1. bean autowired=“byName|byType”
2.基于注解方式
3.spring中工厂原理?

  <bean class=""  id=""/>

原理: 反射 + 构造方法

  Class.forName("com.txw.dao.UserDAOImpl").newInstance();

4.spring管理对象创建次数?
默认: 单例 singleton prototype 多例

   <bean class="" id="" scope="singleton|prototype">   

DAO Service 单例

  Action Struts2 多例   <bean class="" id="" scope="prototype" >

5.spring工厂生命周期?
单例对象: 工厂启动时工厂中所有单例对象随之创建 工厂正常关闭工厂中所有单例对象随之销毁。
多例对象: 每次使用时工厂创建一个新的对象 jvm进行销毁 工厂不负责多例对象的销毁。
6.IOC 和 DI Inversion of Controll 控制反转 DI Denpendency Injection 依赖注入
控制反转: 控制权利的反转
就是将原来手动通过new关键字创建对象权利交给spring由工厂创建对象。
就是将第三方框架中核心对象的创建对象权利交给spring由工厂创建对象。
DI: 依赖注入
为类中需要成员变量赋值过程称之为依赖注入 工厂不仅要创建对象还要维护对象与对象之间的依赖关系。
SET注入语法:
1.八种+String+Date 注入使用property 标签中value属性。
2.对象类型注入使用ref属性。
3.数组注入使用array标签 list set map 分别使用 list set map标签 。
7.spring中AOP Aspect(切面) Oriented Programming 面向切面的编程
原理: 代理设计模式
Proxy: 代理
1.什么时Proxy?
定义: java中一种设计模式。
2.为什么需要代理?
定义: 代理好处 存在代理和不存在代理完成工能一致 。
存在代理将项目中通过 附加操作交给代理去做 目标对象专注于完成自己业务逻辑 代码解耦合 减少代码冗余。
3.静态代理对象
手动的为当前对象开发一个代理对象
开发代理对象:
1.和目标对象实现相同接口。
2.代理对象中依赖于目标对象。
静态代理存在问题?
1.存在大量代码冗余。
4.动态代理
定义: 在程序运行中由jvm帮助我们自动为某个对象产生一个代理对象过程 动态代理 将附加操作 交给动态生成代理对象完成。
5.如何生成动态代理对象?

		// Proxy 用来动态代理对象
		// 参数1: ClassLoader 类加载器  读取.class文件 .class信息   
		static{
    
     只执行一次 } = Thread.currentThread().getContextClassLoader();
		// 参数2: Class[] 创建代理对象的接口类型 
		// 参数3: 附加操作
		UserService userService  = (UserService) Proxy.newInstanceProxy(classLoader,new Class[]{
    
    UserDAO.class},
			new InvocationHanler(){
    
    
				  public Object invoke(Object proxy(代理对象), Method method(方法对象), Object[] args(参数列表)){
    
        // 执行					
					// 解析Mapper配置文件 com.txw.dao.UserDAO  namespace 					
					// 执行方法  method.getName();		// 当前方法名  save  id一致					
					// sql  sql赋值 args   jdbc操作
					// 附加操作
					// method:save
					// com.txw.entity.User  id=21  age=....
					try{
    
     
						// 前置附加操作           
						Object o = method.invoke(new UserServiceImpl(),args);    // 放行目标方法执行
						// 后置附加操作
					}catch(Exception e){
    
    
						// 异常附加操作
					}
					return o;
				  }
			});
		
		userService.getClass  // $proxy0		
		userService.save(new User());

AOP: 封装 额外附加操作 指定附加操作用在项目中那些类上
1.开发附加操作 Advice:通知 附加操作
前置附加操作接口 MethodBeforeAdvice
后置附加操作接口 AfterRetruringAdvice
异常附件操作接口 ThrowsAdvice
环绕附件操作接口 MethodIntercepter
2.配置通知(附加操作)应用与项目中那些类中那些方法 切入点。
切面 Aspect = 通知Advice + 切入点 Pointcut。
3.切入点表达式进行细化
execution 方法级别
within 类级别
@annotation 基于指定注解的切入点表达式
Mybatis框架 UserDAO UserDAOMapper.xml … UserDAO userDAO = sqlSession.getMApper(UserDAO.class);
userDAO.save(new User());
4.ssm整合注意问题?
注意:代理对象是基于接口生成 生成对象只能赋值给接口的引用。
5.面向接口编程 UserService接口 UserServiceImpl
UserServiceImpl 没有接口
注意:
1.Proxy是jdk提供生成代理对象的方式 只能根据接口生成代理对象 jdk(默认采用)。
2.spring框架中作者封装一个基于实现类生成代理对象的方式 CGLIB spring特有的(自动使用CGLIB构建代理对象)。
两种生成代理方式区别?
1.基于接口生成代理只能赋值接口的引用。
2.基于springCGLIB生成代理对象既可以赋值给接口的引用 也可以赋值给实现类引用。
8. mybatis + struts2 整合
1.spring整合mybatis中别名配置如下：

 <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
			<property name="dataSource" ref="dataSource"/>
			<property name="mapperLocations" value="classpath:com/txw/mapper/*.xml"/>
			<!--配置别名设置 默认值: 1.类名  2.类名首字母小写-->
			<property name="typeAliasesPackage" value="com.txw.entity"/>
		</bean>		

2.ssm整合中小配置文件引入

0.提取小配置文件到db.properties

mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/ssm?characterEncoding=UTF-8
mysql.username=root
mysql.password=root

a.第一种读取配置文件的方式  PropertyPlaceholderConfigurer

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
				<!--读取多个配置文件的方式-->
				<property name="locations">
					<array>
						<value>classpath:db.properties</value>
					</array>
				</property>
				<!--读取一个配置文件-->
				<property name="location" value="classpath:db.properties"/>
			</bean>

 b.第二种读取配置文件的方式

<!--第二种读取配置方式-->
<context:property-placeholder location="classpath:db.properties" />	

1.获取配置文件中数据${key}。

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
			<property name="driverClassName" value="${mysql.driver}"/>
			<property name="url" value="${mysql.url}"/>
			<property name="username" value="${mysql.username}"/>
			<property name="password" value="${mysql.password}"/>
		</bean>		

3.spring的配置文件拆分 spring.xml 拆分
classpath:spring-base.xml
classpath:spring-others.xml
1.在spring-base.xml中引入的如下：

<!--引入其他拆分配置文件-->
<import resource="classpath:spring-others.xml"/>