思考：
1. 对象创建创建能否写死？
2. 对象创建细节
对象数量
action 多个 【维护成员变量】
service 一个 【不需要维护公共变量】
dao 一个 【不需要维护公共变量】
创建时间
action 访问时候创建
service 启动时候创建
dao 启动时候创建
3. 对象的依赖关系
action 依赖 service
service依赖 dao
=======================================================
总结：
spring就是解决上面的问题的！
简单来说，就是处理对象的创建的、以及对象的依赖关系！
2. Spring框架
2.1 专业术语了解
组件/框架设计
侵入式设计
引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
例如： Struts框架
非侵入式设计
引入了框架，对现有的类结构没有影响。
例如：Hibernate框架 / Spring框架
控制反转:
Inversion on Control , 控制反转 IOC
对象的创建交给外部容器完成，这个就做控制反转.
依赖注入：dependency injection ， 处理对象的依赖关系
区别：
控制反转： 解决对象创建的问题 【对象创建交给别人】
依赖注入：在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
AOP
面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。
切面举例：事务、日志、权限;
2.2 Spring框架
a. 概述
Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
且可以和其他框架一起使用；Spring与Struts, Spring与hibernate
(起到整合（粘合）作用的一个框架)
Spring提供了一站式解决方案：
1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web Spring对web模块的支持。
a. 可以与struts整合,让struts的action创建交给spring
b. spring mvc模式
3） Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
4） Spring ORM spring对orm的支持：
a. 既可以与hibernate整合，【session】
b. 也可以使用spring的对hibernate操作的封装
5）Spring AOP 切面编程
6）SpringEE spring 对javaEE其他模块的支持
b. 开发步骤
spring各个版本中：
在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】，如2.5版本；
在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】，(如果要用依赖包，需要单独下载！)
1） 源码, jar文件：spring-framework-3.2.5.RELEASE
commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean节点
spring-context-3.2.5.RELEASE.jar spring上下文节点
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表达式相关表
以上是必须引入的5个jar文件，在项目中可以添加用户库管理！Add-Libray
2） Spring配置文件：applicationContext.xml或者为 bean.xml
约束参考：
spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html
<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"
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">
<!-- IOC容器的配置： 要创建的所有的对象都配置在这里-->
<bean id="user" class="cn.itcast.a_hello.User"></bean>
</beans>
3）Api
public class App {
// 1.方式一： 通过工厂类得到IOC容器创建的对象
@Test
public void testIOC() throws Exception {
// 以前，创建对象
// User user = new User();
// 现在，把对象的创建交给spring的IOC容器
Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");这个用路径，不是包名，是/ 不是.
// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
BeanFactory factory = new XmlBeanFactory(resource);
// 得到容器创建的对象
User user = (User) factory.getBean("user");
System.out.println(user.getId());
}
//2. 方式二：（方便）直接得到IOC容器对象 ，推荐使用这种方式
@Test
public void testAc() throws Exception {
// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
// 从容器中获取bean
User user = (User) ac.getBean("user");
System.out.println(user);
}
}
2.3. bean对象创建的细节
public class App2_bean {
/**
* 1) 对象创建： 单例/多例
* scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
* scope="prototype", 多例； 【Action对象】
*
* 2) 什么时候创建?
* scope="prototype" 在用到对象的时候，才创建对象。
* scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
* 3)是否延迟创建
* lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
* lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象 （只对单例有效）
* 4) 创建对象之后，初始化/销毁
* init-method="init_user" 【对应对象的init_user方法，在对象创建爱之后执行 】
* destroy-method="destroy_user" 【在调用容器对象的destroy方法时候执行，(容器用实现类)】
*/
@Test
public void testIOC() throws Exception {
// 得到IOC容器对象 【用实现类，因为要调用销毁的方法】
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
System.out.println("-----容器创建-----");
// 从容器中获取bean
User user1 = (User) ac.getBean("user");
User user2 = (User) ac.getBean("user");
System.out.println(user1);
System.out.println(user2);
// 销毁容器对象 ,user对象的销毁destroy方法也会执行
ac.destroy();
}
@Test
public void test() throws Exception {
// 容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
System.out.println("-----容器创建完成-----");
User user1 = (User) ac.getBean("user1");
}
}
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:p="http://www.springframework.org/schema/p"
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">
<!-- IOC容器的配置： 要创建的所有的对象都配置在这里-->
<bean id="user" class="cn.itcast.a_hello.User" init-method="init_user" destroy-method="destroy_user" scope="singleton" lazy-init="false">
</bean>
</beans>
public class User {
private int id;
private String name;
public User() {
super();
System.out.println("------User对象创建------");
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void init_user() {
System.out.println("创建对象之后，初始化");
}
public void destroy_user() {
System.out.println("IOC容器销毁，user对象回收!");
}
}
2.4. Spring IOC容器
1） 创建对象
Spring IOC容器，是spring核心内容。
作用： 创建对象 & 处理对象的依赖关系
IOC容器创建对象：因为对象需要IOC容器来创建，所以创建对象的时候，要明确用哪种方式来创建，即通过配置文件来指定。
创建对象, 有几种方式：
1） 调用无参数构造器
2） 带参数构造器
3） 工厂创建对象
工厂类，静态方法创建对象
工厂类，非静态方法创建对象
<?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"
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">
<!-- ###############对象创建############### -->
<!-- 1. 默认无参数构造器 -->
<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
<!-- 2. 带参数构造器 -->
<bean id="user2" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>第一个参数，类型，值 （基本类型直接写，引用类型写全名，如下面的string类型）
<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>第二个参数，类型，值
</bean>
注意，上面的构造函数的参数可能不是基本类型，有可能是一个其他类的对象，这时候该如何处理？？？？
<!-- 定义一个字符串，值是"Jack" ; String s = new String("jack")-->
<bean id="str" class="java.lang.String">
<constructor-arg value="Jacks"></constructor-arg>
</bean>
<bean id="user3" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg> 在这里引用上面创建的对象，同理可以是其他的对象，如User类等
</bean>
<!-- 3. 工厂类创建对象 -->
<!-- # 3.1 工厂类，实例方法 -->
<!-- 先创建工厂 -->
<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
<!-- 在创建user对象，用factory方的实例方法 -->
<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean> 实例方法创建一定要用工厂对象来创建，即factory-bean
<!-- # 3.2 工厂类： 静态方法 -->
<!--
class 指定的就是工厂类型
factory-method 一定是工厂里面的“静态方法”
-->
<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
静态方法不需要实例对象，即不需要factory-bean
<!-- 对象写法 -->
<!--
问题：spring配置文件中，bean节点的id与name属性的区别?
id 不能有特殊符号, 且唯一，且不能以数字开始
name 可以有特殊符号
-->
<bean id="test" name="1test" class="cn.itcast.b_create_obj.User"></bean>
</beans>
// 工厂，创建对象 上面的配置文件中，配置如何用工厂模式创建对象
public class ObjectFactory {
// 实例方法创建对象
public User getInstance() {
return new User(100,"工厂：调用实例方法");
}
// 静态方法创建对象
public static User getStaticInstance() {
return new User(101,"工厂：调用静态方法");
}
}
2） 对象依赖关系
Spring中，如何给对象的属性赋值? 【DI, 依赖注入】
1) 通过构造函数
2) 通过set方法给属性注入值
3) p名称空间
4)自动装配(了解)
5) 注解
public class App {
// 创建容器对象
private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean.xml");
@Test
public void testSet() {
// 从容器中获取
User user = (User) ac.getBean("user");
System.out.println(user);
}
@Test
public void testExecuteAction() {
// 从容器中获取Action
UserAction userAction = (UserAction) ac.getBean("userAction");
userAction.execute();
}
}
<?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"
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">
<!-- ###############对象属性赋值############### -->
<!-- 1) 通过构造函数 -->
<bean id="user1" class="cn.itcast.c_property.User" scope="prototype">
<constructor-arg value="100"></constructor-arg>
<constructor-arg value="Tom"></constructor-arg>
</bean>
<!-- 2) 通过set方法给属性注入值 -->
<bean id="user" class="cn.itcast.c_property.User" scope="prototype">
<property name="id" value="101"></property>
<property name="name" value="Jack"></property>
</bean>
</beans>
案例：
MVC模式下的处理方式转变：
Dao层：模拟操作数据库
public class UserDao {
public void save() {
System.out.println("DB:保存用户");
}
}
service层：
public class UserService {
private UserDao userDao; // = new UserDao();
// IOC：对象的创建交给spring的外部容器完成
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
userDao.save();
}
}
action类：
public class UserAction {
// Service: springIOC容器注入
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public String execute() {
userService.save();
return null;
}
}
public class App { 在一个类中调用一个action？？？？？？？？
// 创建容器对象
private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean.xml");
@Test
public void testExecuteAction() {
// 从容器中获取Action
UserAction userAction = (UserAction) ac.getBean("userAction");
userAction.execute();
}
}
配置文件bean.xml
(常用)Set方法注入值
<!-- dao instance -->一般项目中所有的dao的instance写在一起
<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
<!-- service instance -->创建service对象时候，一定要注入它的依赖对象userDao，依赖的是一个对象，需要用引用
<bean id="userService" class="cn.itcast.c_property.UserService">
<property name="userDao" ref="userDao"></property> 上面的userdao配置放在下面也没关系，跟顺序无关
</bean>
<!-- action instance -->
<bean id="userAction1" class="cn.itcast.c_property.UserAction">
<property name="userService" ref="userService"></property>
</bean>
上面的方式userDao，servicedao实例都加入到spring的IOC容器，其他对象都可以使用该实例。
内部Bean
<!-- ##############内部bean############## --> 功能与上面一样。
<bean id="userAction2" class="cn.itcast.c_property.UserAction">
<property name="userService">
<bean class="cn.itcast.c_property.UserService">
<property name="userDao">
<bean class="cn.itcast.c_property.UserDao"></bean>
</property>
</bean>
</property>
</bean>
功能一样，都可以创建action对象，并处理了action对象的依赖关系。
内部bean的方法创建的userdao是内部的，只能供useraction2使用，其他对象用不到，一般不用这种方式，当只使用一次的时候可以这么用，但不推荐。
# p 名称空间注入属性值 (优化)
<?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" p名称空间
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">
<!-- ###############对象属性赋值############### -->
<!--
给对象属性注入值：
# p 名称空间给对象的属性注入值
(spring3.0以上版本才支持)
-->
<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
<bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
<bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>
<!-- 传统的注入：
<bean id="user" class="cn.itcast.c_property.User" >
<property name="name" value="xxx"></property>
</bean>
-->
<!-- p名称空间优化后 --> p:name=是直接给属性赋值，p:name-ref是对象的引用
<bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
</beans>
# 自动装配(了解)
根据名称自动装配：autowire="byName"
自动去IOC容器中找与属性名同名的引用的对象，并自动注入
<!-- ###############自动装配############### -->
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
<!-- 根据“名称”自动装配： userAction注入的属性，会去ioc容器中自动查找与属性同名的对象 -->
<bean id="userAction"
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>
也可以定义到全局， 这样就不用每个bean节点都去写autowire=”byName”
<?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"
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" default-autowire="byName"> 根据名称自动装配（全局）
<!-- ###############自动装配############### -->
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
<bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
</beans>
根据类型自动装配：autowire="byType"
必须确保改类型在IOC容器中只有一个对象；否则报错。
<?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"
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" default-autowire="byType">
<!-- ###############自动装配############### -->
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
<!-- 如果根据类型自动装配： 必须确保IOC容器中只有一个该类型的对象 -->
<bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
<!-- 报错： 因为上面已经有一个该类型的对象，且使用了根据类型自动装配
<bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
-->
</beans>
总结： Spring提供的自动装配主要是为了简化配置； 但是不利于后期的维护。 (一般不推荐使用)
# 注解
注解方式可以简化spring的IOC容器的配置! 缺点是不利于维护。
使用注解步骤：
1）先引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
2）开启注解扫描，扫描指定包及子包下所有的类
<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
3）使用注解
通过注解的方式，把对象加入ioc容器。
创建对象以及处理对象依赖关系，相关的注解：
@Component 指定把一个对象加入IOC容器
@Repository 作用同@Component； 在持久层使用
@Service 作用同@Component； 在业务逻辑层使用
@Controller 作用同@Component； 在控制层使用
@Resource 属性注入
bean.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:p="http://www.springframework.org/schema/p"
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">
<!-- 开启注解扫描 -->
<context:component-scan base-package="cn.itcast.e_anno"></context:component-scan>会扫描当前包及子包中所有的类
</beans>
userdao：
// 把当前对象加入ioc容器
@Component("userDao") // 相当于bean.xml 【<bean id=userDao class=".." />】
public class UserDao {
public void save() {
System.out.println("DB:保存用户!!!");
}
}
userservice:
@Component("userService") // userService加入ioc容器
public class UserService {
// 会从IOC容器中找userDao对象，注入到当前字段
/*
* <bean id="" class="">
* <property name="userDao" ref="userDao" /> @Resource相当于这里的配置
* </bean>
*/
@Resource(name = "userDao") 这里相对于是用名字在IOC容器中查找，可以有多个该类的实例
@Resource 这是简化注解，是用类型去IOC容器中取查找，但是要求在IOC容器中，必须只有该类的一个实例，否则报错，因为他不知道要用哪个实例对象注入
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
userDao.save();
}
}
UserAction :
import org.springframework.stereotype.Component;
@Component("userAction") // 加入IOC容器
public class UserAction {
@Resource(name = "userService")
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public String execute() {
userService.save();
return null;
}
}
public class App {
// 创建容器对象
private ApplicationContext ac =
new ClassPathXmlApplicationContext("cn/itcast/e_anno/bean.xml");
@Test
public void testExecuteAction() {
// 从容器中获取Action
UserAction userAction = (UserAction) ac.getBean("userAction");
userAction.execute();
}
}
总结：
1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
2） 注解可以和XML配置一起使用。
3. Spring与Struts框架整合
Spring，负责对象对象创建
Struts， 用Action处理请求
Spring与Struts框架整合，
关键点：让struts框架action对象的创建，交给spring完成！
Spring与Hibernate整合：
【SSH整合:
Spring与Struts
关键点： action交给spring创建!
Spring与Hibernate
关键点： sessionFactory对象交给spring创建！
】
步骤：
引入jar文件
1）引入struts .jar相关文件
2）spring-core 相关jar文件
3）spring-web 支持jar包
spring-web-3.2.5.RELEASE.jar 【Spring源码】
struts2-spring-plugin-2.3.4.1.jar 【Struts源码】
配置:
4）配置XML
struts.xml 【struts路径与action映射配置】
bean.xml 【spring ioc容器配置】
web.xml
【核心过滤器： 引入struts功能】
【初始化spring的ioc容器】
【初始化spring的ioc容器】
查看api。
4） 代码以及配置
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd">
<!-- 1. 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>
<!-- 2. spring 配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/bean-*.xml</param-value> src下的文件会自动部署到WEB-INF/classes目录下
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
bean-dao.xml 项目中所有的dao的bean都配置在这里
<?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"
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/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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<bean id="userDao" class="cn.itcast.dao.UserDao" scope="singleton" lazy-init="false"></bean>
</beans>
bean-service.xml 项目中所有的service都配置在这里
<?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"
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/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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<bean id="userService" class="cn.itcast.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
</beans>
bean-action.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:p="http://www.springframework.org/schema/p"
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/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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 指定action多例 -->
<bean id="userAction" class="cn.itcast.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
</beans>
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">
<action name="user" class="userAction" method="execute">
<result name="success">/index.jsp</result>
</action>
</package>
</struts>
