Spring快速入门

导入jar包

1. 核心：必须要导入的
   beans
   context
   core
   Expression
   commons-logging

依赖：Spring 3.之后，所有的依赖包不包含，需要时导入

2. 核心配置文件
   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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
  	 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
 	 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
        
<!-- IOC容器配置：所有需要用到的类对象 -->
<!-- 
id:标识
class: 类的完全限定名
-->
<bean id="user" class="com_fq_first.User" scope="singleton"> </bean>
            
</beans>

IOC容器配置：所有需要用到的类对象

把对象的创建交给Spring的IOC容器

• 得到IOC容器

@SuppressWarnings("resource")
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

• 从容器中获取对象

User user =(User) ac.getBean("user");

1）对象的创建：单例 多例

• scope : 值为 singleton 单例模式 singleton:Spring容器只存在一个共享的bean实例，默认的配置
• scope : 值为 prototype 多例模式 prototype: 每次对bean的请求都会创建一个新的bean实例

2）什么时候创建？

scope=“singleton” 在启动 IOC容器初始化之前 创建bean,整个应用只有一个对象
scope=“prototype” 在对象被使用的时候创建

3）是否延迟创建？

lazy-init =“default” 默认为false不延迟，启动时创建 lazy-init = “true”
启动时不创建，使用时创建

4 ) 创建对象之后的初始化 与销毁

init-method = “init_user” ; 对象初始化时调用的方法
destroy-method =“destroy_user”; 对象被销毁时调用的方法

SpringIOC容器：

SpringIOC容器：是spring核心内容 作用：创建对象 ， 处理对象的依赖关系

一）IOC容器创建对象：
几种方式：

1. 调用无参构造
2. 调用带参数构造
3. 工厂创建对象

工厂类：静态方法创建对象
非静态方法创建对象

<!-- 1.无参数构造 -->
<bean id="person" class="com_fq_first.Person" > </bean>

<!-- 2-1.带参数构造 -->
<bean id="person2" class="com_fq_first.Person" >
	<constructor-arg value="zhangsan" index="1" type="int"></constructor-arg>
	<constructor-arg value="101" index="0" type="java.lang.String"></constructor-arg>
</bean>

<!-- 2-2.带参构造  引用其他对象 -->
<bean id="s" class="java.lang.String" > 
	<constructor-arg value="Tom"></constructor-arg>
</bean>
 
<bean id="person3" class="com_fq_first.Person" >
	<constructor-arg value="101" ></constructor-arg>
	<constructor-arg index="1" ref="s" ></constructor-arg>
</bean>

<!-- 3-1工厂创建对象 -->
<!-- 工厂类的实例 -->
<bean id="person_factory" class="com_fq_first.PersonFactory" > </bean>
<!-- 使用实例方法创建对象 -->
<bean id="person4" factory-bean="person_factory" factory-method="getInstance"> </bean>

<!-- 3-2工厂创建对象 静态方法 -->
<bean id="person5" class="com_fq_first.PersonFactory"  factory-method="getStaticInstance" >  </bean>

二）对象依赖关系：
DI：依赖注入

1. 通过构造注入
   （同上面构造注入 <! – 2-1.带参数构造 --> <! – 2-2.带参构造 引用其他对象 -->）
2. 通过set方法对属性注入（常用）

<!-- 通过set方法对属性注入 -->
<bean id="person" class="com_fq_first.Person" >
	<property name="id" value="106"></property>
	<property name="name" value="dadada"></property>
</bean>

注：name属性值 为：类的set方法去掉set，然后首字母小写
例如：Person类中 id的set方法

public void setId(int id) {
System.out.println("----使用setId方法注入属性id----");
this.id = id; 
}

Action Service Dao对象的依赖关系：

<!-- 方式一 -->
<!--   Dao -->
<bean id="userDao" class="com.fq.first.UserDao"></bean>
<!--   Service-->
<bean id="userService" class="com.fq.first.UserService">
    <property name="userDao"  ref="userDao"></property>
</bean>
<!--   Action-->
<bean id="userAction" class="com.fq.first.UserAction">
    <property name="userService" ref="userService"></property>
</bean>

<!-- 方式二：内部bean -->
<bean id="userAction2" class="com.fq.first.UserAction">
        <property name="userService" >
            <bean class="com.fq.first.UserService">
                <property name="userDao">
                    <bean class="com.fq.first.UserDao"></bean>
                </property>
            </bean>
        </property>
 </bean>

3，P名称空间. 属性注入优化

<!-- 1) 使用property属性-->
<bean id="user" class="com_fq_first.User" >
	<property name="id" value="1011"></property>
	<property name="name" value="jack"></property>
</bean>

<!-- 2)	使用p命名空间-->
<bean id="user" class="com.fq.first.User" p:id="1088" p:name="jack1">
</bean>

<!--   使用property属性 -->
<!--   Dao -->
<bean id="userDao" class="com.fq.first.UserDao"></bean>
<!--   Service-->
<bean id="userService" class="com.fq.first.UserService">
    <property name="userDao"  ref="userDao"></property>
</bean>
<!--   Action-->
<bean id="userAction" class="com.fq.first.UserAction">
    <property name="userService" ref="userService"></property>
</bean>

<!--   使用p命名空间 -->
<!--   Dao -->
<bean id="userDao" class="com.fq.first.UserDao" > </bean>
<!--   Service-->
<bean id="userService" class="com.fq.first.UserService" p:userDao-ref="userDao"> </bean>
<!--   Action-->
<bean id="userAction" class="com.fq.first.UserAction"  p:userService-ref="userService"> </bean>

自动装配

<bean id="userDao" class="com.fq.first.UserDao" > </bean>
<bean id="userService" class="com.fq.first.UserService" autowire="byName"> </bean>
<bean id="userAction" class="com.fq.first.UserAction"  autowire="byName">
</bean>

4，自动装配 （了解部分）

通过名称自动装配 autowire=“byName” 自动的在IOC容器中找属性名同名的对象 自动注入 定义全局 ：
在根</beans autowire=“byName”> 根据类型：autowire=“byType”
适用于IOC容器中只有一个类型的对象，否则报错 注意：Spring提供的自动装备主要是为了简化配置，但不利于后期的维护（不推荐）

5，注解方式
可以简化SpringIOC容器的配置

使用注解步骤：

1. 先引入context名称空间

xmlns:context="http://www.springframework.org/schema/context"

2. 开启注解扫描

<!-- base-package 扫描的包及子包下的类-->
<context:component-scan base-package="com.fq.second"></context:component-scan>

使用注解：

把对象加入IOC容器。@Component(“userDao”)
类似于：

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

@Component // 不写括号内容，表示在IOC容器加入的对象名称与类名相同，第一个字母小写，userDao

处理对象依赖关系：
属性注入，写在字段上面 @Resource(name =“userDao”)
类似于：

<bean id="userService" class="com.fq.first.UserService">
    <property name="userDao"  ref="userDao"></property>
</bean>

@Resource // 不写括号内容，表示根据类型查找。 找到注入

注解：
@Repository // 在持久层使用
@Service //在业务逻辑层使用
@Controller // 在控制层使用

总结：使用注解，可以简化配置 ，且可以把对象加入到IOC容器中，处理依赖关系 注解可以和XML配置一起使用