ssm（2）spring

1.ioc

1）设值注入

<bean id="helloworld" class="spring1.HelloWorld">
       <property name="name" value="Spring"></property>
</bean>

2）构造注入

按顺序
<bean id="car"  class="spring1.Car">
       <constructor-arg value="audi"></constructor-arg>
       <constructor-arg value="shanghai"></constructor-arg>
       <constructor-arg value="3000"></constructor-arg>
</bean>

按类型
<bean id="car2"  class="spring1.Car">
       <constructor-arg value="audi" type="java.lang.String"></constructor-arg>
       <constructor-arg value="shanghai" type="java.lang.String"></constructor-arg>
       <constructor-arg value="3000" type="int"></constructor-arg>
</bean>

混合使用
<bean id="car3"  class="spring1.Car">
       <constructor-arg value="audi" type="java.lang.String"></constructor-arg>
       <constructor-arg value="shanghai" index="1"></constructor-arg>
       <constructor-arg value="3000" type="int"></constructor-arg>
</bean>

3）对特殊符号的处理

4）bean之间的相互引用

<!— ref=“id” -->
<bean id="person" class="spring1.Person">
       <property name="name" value="tom"></property>
       <property name="age" value="28"></property>
       <property name="car" ref="car3"></property>
</property>

5）内部bean

<bean id="person" class="spring1.Person">
       <property name="name" value="tom"></property>
       <property name="age" value="28"></property>
       <property name="car">
       <bean  class="spring1.Car">
       <constructor-arg value="audi" type="java.lang.String"></constructor-arg>
       <constructor-arg value="shanghai" index="1"></constructor-arg>
       <constructor-arg value="3000" type="int"></constructor-arg>
       </bean>
       </property>
</bean>

6）级联

7）集合属性的构建

List
<list>
       <ref bean="car1"/>
       <ref bean="car2"/>
       <ref bean="car3"/>
       <!-- 内部bean的方式书写 -->
       <bean  class="spring1.Car">
       <constructor-arg value="audi" type="java.lang.String"></constructor-arg>
       <constructor-arg value="shanghai" index="1"></constructor-arg>
       <constructor-arg value="3000" type="int"></constructor-arg>
       </bean>
</list>

Map
<property name="cars">
       <map>
       <entry key="aa" value-ref="car"> </entry>
       <entry key="bb" value-ref="car1"> </entry>
       <entry key="cc" value-ref="car2"> </entry>
       </map>
</property>

Property
<property name="properties">
       <props>
       <prop key="user">root</prop>
       <prop key="password">cgz12345678</prop>
       <prop key="jdbcurl">jdbc:mysql:///test</prop>
       <prop key="driverclass">com.mysql.Driver</prop>
       </props>
</property>

备注：在不能识别构造方法时，会执行最后一个满足条件的构造方法

8）实例工厂（用的少）

<bean id="factory" class="cn.spring.test.InstanceFactory" ></bean>
<bean id="car1" factory-bean="factory"  factory-method="getCar">
	<constructor-arg value='audi'></constructor-arg>
</bean>
private Map<String,Car> cars=new HashMap<>();
public InstanceFactory() {
	cars.put("audi", new Car("audi", 300000));
	cars.put("ford", new Car("ford", 400000));
}
public Car getCar(String name){
	return cars.get(name);
}

9）静态工厂方法（用的少）

static{
	cars.put("audi", new Car("audi", 300000));
	cars.put("ford", new Car("ford", 400000));
}
public static Car getCar(String name){
	Car car = cars.get(name);
	return car;
}
<bean id="car" class="cn.spring.test.StatiCarFactory" factory-method="getCar">
	<constructor-arg value="audi"></constructor-arg>
</bean>

10）抽像bean

<!--不需要class，abstract=“true”-->
<bean id="address2" p:city="shanghai" p:street="dongfang" abstract="true"></bean>
<!--parent="address2"-->
<bean id="address1" class="spring3.Address"parent="address2" p:street="haoxida"></bean>
<!-- depends-on="car" 初始化前需要有一个id为car的bean-->
<bean id="person" class="spring3.Person"p:name="tom" p:address-ref="address1" depends-on="car"></bean>

备注：di依赖注入，一个类依赖另外一个类，ioc控制反转，手动实例化bean变成自动实例化bean

11）执行

ApplicationContext ctx = new ClassPathXmlApplicationContext("xmlpath");
//根据id名获取对象
Car car1 = (Car) ctx.getBean("car1");
//根据类型名获取对象，且这个类型的id只能有一个否则报错
HelloWorld bean = ctx.getBean(HelloWorld.class);

12）util命名空间

单独bean

<util:list id="list">

</util:list>

<util:properties id="resource" location="path"></util:properties>

<util:constant id="age" static-field="Tese.age"/>

<util:property-path id="age" path="Test.age"/>

13 ）p命名空间

14）自动装配

// autowire="byName" 默认值no表示不进行自动装配，byname与bytype只能选一个这个方法是存在弊端的而且弊大于利，byname 根据bean的名字和当前的bean的setter风格的属性进行装配，当存在是就装配，不存在时就不装配，bytype 根据bean的类型和当前bean的属性的类型进行自动装配若ioc存在一个以上，会抛出异常，一般很少用自动配置，在整合第三方框架的时候会使用

2.作用域scope

songleton 默认值，表示单例模式，在这个周期类值创建一个bean只初始化一次，在创建容器的时候就已经创建好了

Prototype原型模式，在getbean的时候创建相应的bean，在容器创建的时候不会创建bean ，而是在每次getbean的时候都会创建新的bean

session对应于域对象的session，每次http session时创建一个bean对象，在web中使用时才有效

request对应于域对象的request，每次http request时创建一个bean对象，在web中使用时才有效

备注：Singletom依赖prototype的时候会出现prototype不更新问题的解决方式

//steel为抽象类 getAxe为抽象方法

<，up-method name="getAxe" bean="steel"/>

对于getAxe方法由spring完成源码如下

Public axe getaxe（）{

　　Return ctx.getbean（“steel”）

}

3.Spring IOC 容器对 Bean 的生命周期进行管理的过程:

通过构造器或工厂方法创建 Bean 实例，为 Bean 的属性设置值和对其他 Bean 的引用，将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法，调用 Bean 的初始化方法init，将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法，Bean 可以使用了，当容器关闭时, 调用 Bean 的销毁方法destroy

备注：

1）init方法和destroy方法的指定（bean无需实现任何接口和继承）

2）bean的后处理器

后处理需要实现 beanpostprocessor接口，在配置文件中添加初始化如<bean class="spring5.Mybeanpostprocesse"></bean>

其中的两个方法

postProcessBeforeInitialization 方法 Bean 的初始化之前调用

postProcessAfterInitialization方法 Bean 初始化之后调用

4.注解

1） Spring没有采用约定大于配置

2） annotation注解

@configuration：用于修饰一个javabean

@bean：用于修饰一个方法，将该方法的返回值定义成容器中的一个bean，@bean{name=“chinese”} 配置一个bean：chinese

@value：用于修饰一个field，用于作为一个配置的值，@value{“张三”} 注入需要依赖注入的属性值

@import 修饰装配类用于导入其他java配置类进行整合

@scope：修饰一个方法，指定scope生命域 @Scope("prototype")

@lazy 修饰一个方法对应的bean是否延迟初始化，@lazy（true）延迟初始化

@dependon 修饰一个一个方法初始化对应的bean之前初始化指定bean，依赖其他的bean，其中还有几个属性，类似于xml配置中的init和destroy

@importresource 导入xml配置

@importresource{“classpath：/bean.xml”}

3）注解扫描组件

@Component: 基本注解, 标识了一个受 Spring 管理的组件

@Respository: 标识持久层组件

@Service: 标识服务层(业务层)组件

@Controller: 标识表现层组件

对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称，当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan> ：，base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个基类包里及其子包中的所有类，当需要扫描多个包时, 可以使用逗号分隔，如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类

<context:component-scan base-package="spring7" resource-pattern="*.class">

<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>

<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>

<context:include-filter type="assignable" expression="spring7.UserRepositoryimp"/>

</context:component-scan>

<context:include-filter> 和 <context:exclude-filter> 子节点支持多种类型的过滤表达式

4）自动装配

@ Autowired：可用于多个参数的普通方法传递参数，也可以用于构造方法传递参数和field

@Autowired属性

Name：属性名自动装配

Type：根据属性的类型自动装配，没有bean什么都不会发生，多个相同类型报出异常

Auto：spring插件会自动检查需要哪种自动装配的类型

Constructor：与type相似，区别是使用构造器来构造注入需要的参数

@Autowired(required=false)表示即使没有这个属性相匹配的类也不会报错

当存在多个匹配时（多态或者继承）

那么可以通过@Controller（value）指定value的值，优先匹配属性名与value一致的值，或者@Qualifier(value)指定

@resource可以注释setter方法的参数和属性

@resource（）

Private person ps；

注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称

类似于property的ref

@Inject

@Inject和 @Autowired 注解一样也是按类型匹配注入的 Bean，但没有 reqired 属性

5）作用域

@scope

如：@scope（“prototype”）

6）@dependon

依赖，可修饰bean类和方法，需要初始化其他bean

7）@lazy

Boolean参数，指定是否预初始化该bean

8）泛型注入

Spring 4 中可以为子类注入子类对应的泛型类型的成员变量的引用

猜你喜欢