spring基础——ssh学习笔记

原创 2016年08月31日 14:45:37

Spring 基础

1.Spring将容器中的一切对象称为bean
2.spring通过xml(或配置文件)管理bean,利用反射

<beans>
<bean id="" class="必须是带包名的完整类名">
</beans>

3.ApplicationContext是最常用的接口

,有两个具体实现的类:
ClassPathXmlApplicationContext:从类加载路径上搜索配置文件
FileSystemXmlApplicationContext:使用相对路径或绝对路径搜索配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
Person person = ctx.getBean("person",Person.class);//或者使用getBean(String id)

依赖注入和控制反转

:不同的名字相同的意思,就是调用者无需关心被调用者的实现,等待spring注入。
4.constructor-args构造函数的参数值,其实就是反射调用含参的构造函数

//两种形式:传入对象,传入值
<constructor-arg ref="id"//该值指向另一个bean/>
<constructor-arg value="hello"/>

相比较而言,这种构造注入的方式没有依赖注入好,因为不仅使得构造器臃肿,最主要的spring创建bean时,需要初始化全部的依赖的bean
但是datasource使用构造注入,因为很多其他组件依赖于它,它必须优先于它们注入。

spring容器:

BeanFactory:管理bean,applicationContext是其子接口

//实例化beanFactory
Resource isr = new ClassPathResource("beans.xml");
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

//讲配置文件传入beanFactory
new XmlBeanDefinitionReader(beanFactory).loadBeanDefinitions(isr);

如果需要加载多个配置文件,则使用ApplicationContext

ApplicationContext app = new ClassPathXmlApplicationContext("a.xml","b.xml")

ApplicationContext

1.applicationContext在创建时,会初始化所有的singleton Bean(没有任何特殊配置),包括完成初始化和创建实例,但beanFactory不会。
如果想要阻止初始化,可在bean中设置

2.国际化支持
applicationContext继承了MessageSource接口

<bean id="messageSource" class="org.spring....MessageSource">
<property name="basenames">
    <list>
        <value>message_a</value>
        <value>message_b</value>
    </list>
</property>

/**MessageSource接口中定义的是
*getMessage(String code,Object[] a,Local loc);
*getMessage(String code,Object[] a,String default,Local loc);
**/
//调用
String a = ctx.getMessage("hellow",new String[]{"haha"},Local.getDefault(Locale.Category.FORMAT));

事件机制——观察者模式

ApplicationEvent和ApplicationListener
当ApplicationContext发布ApplicationEvent时,自动触发ApplicationListener

//event类
class EmailEvent extends ApplicationEvent{
 //一个普通的java类
}
//listener
class EmailNotifier implements ApplicationListener{
public void onApplicationEvent(ApplicationEvent evt){
if(evt instanceof EmailEvent)
}
}
//无需再代码中完成观察者,只要讲listener在beans中注册就行了
<bean class="xxxxx.EmailNotifier"/>

//实际调用
ApplicationContext ctx = new ...
EmailEvent ele = new EmailEvent();
ctx.publishEvent(ele);//触发事件时自动调用listener

ApplicationContextAware接口:使得bean可以获取spring容器

//将容器以变量形式保存
private ApplicationContext cx;
//spring在创建bean后会自动检测是否实现了aware接口,如果是,自动调用set方法,无需显式设置
public void setApplicationContext(ApplicationContext ctx){
this.ctx = ctx;
}

Bean的作用域

singleton:单例模式,整个spring容器中,只会生成一个实例
prototype:每次通过容器的getBean()方法获取prototype作用于的bean时,生成一个实例
request/session/global session

<bean id="p1" scope="singleton">//或者不写
<bean id ="p2" scope="prototype">

ctx.getBean("p1") == ctx.getBean("p1") true
ctx.getBean("p2") == ctx.getBean("p2") false

Bean 的创建方法

1.调用构造器创建Bean
2.使用静态工厂方法创建Bean
bean的class属性指向的是实现该实例的静态工厂类

interface Being{
public void testBeing();
}
class Dog implements Being{
private String msg;
public void testBeing(){
    System.out.println(msg);
}
}
public class BeingFactory{
    public static Being getBeing(String arg){
    if(arg.equalsIgnoreCase("dog")){//忽略大小写
        return new Dog();
    }
    }
} 

//xml中配置
<bean id="dog" class="xx.BeingFactory" factory-method="getBeing">
    <constructor-arg value=="dog"/>
    <property name="msg" value="I am dog">
</bean>

3.实例工厂创建Bean

interface Person{}
class Chinese implements Person{}
class PersonFactory{
public Person getPerson(String a){
    if(a.equalsIgnoreCase("chin")){
        return new Chinese();
    }
}
}
//配置文件
PersonFactory pf = container.get("personFactory");
chinese = pf.getPerson("chin");
<bean id="chinese" factory-bean="personFactory" factory-method="getPerson">
<constructor-arg value="chin">
</bean>

抽象Bean

<bean id="personTemplate" abstract="true">
    <property name="name" value="a"/>
</bean>
<bean id="chinese" class="" parent="personTemplate"/>

4.BeanNameAware
用于获取bean本身的id

协调作用域不同的Bean

比如一个singleton依赖于prototype,当初始化singleton时,就会生成对应的prototype实例,之后通过singleton调用prototype就不能够每次都产生新的实例
解决:方法注入(字节码修改)

public abstract class Chinese implements Person{
private Dog dog;
public abstract Dog getDog();
public void hunt(){
 getDog();
}
}

//xml中配置
<bean id="chinese" class="xx.Chinese">
    <lookup-method name="getDog" bean="gunDog"/>
</bean>
<bean id="gunDog" class="xx.GunDog" scope="prototype">
    <property name="name" value="xiaobai">
</bean>

按我的理解,应该是spring按照配置文件每次调用chinese中hunt方法时,会动态修改字节码,加载具体的方法,所以每次生成的都是新的dog对象

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

spring2.5学习笔记以及SSH

  • 2010-07-23 11:39
  • 545KB
  • 下载

Spring.NET学习笔记10——方法的注入(基础篇)

多数用户都会将容器中的大部分对象布署为singleton模式。当一个singleton对象需要和另一个singleton对象协作,或者一个非singleton对象需要和另一个非singleson对象协...

SSH_ORACLE_SPRING学习笔记

  • 2016-04-27 10:49
  • 1.02MB
  • 下载

Spring.NET学习笔记4——对象的创建(基础篇)

学过了前面的课程,我们来一起学习Spring.NET的IoC容器对象的创建。  创建对象一般有3种方式:1.构造器创建,2.静态工厂创建,3.实例工厂创建  多数情况下,容器会根据对象定义中的type...

Spring.NET学习笔记7——依赖对象的注入(基础篇)

一、属性注入  上篇我们简单提到依赖注入的用途。回顾一下所讲内容,发现在object节点下使用了。而property 标签正是用来属性注入的。而ref是用来标识是关联到哪个object。而name属性...

Spring.NET学习笔记11——自定义对象行为(基础篇)

Spring.NET通过几个专门的接口来控制容器中对象的行为。说到对象的行为无非就要提到对象的生命周期控制。类似在WinForm开发,Form生命周期中,Load方法为Form的载入方法和Dispos...

Spring.NET学习笔记13——AOP的概念(基础篇)

上篇我们简单的了解了AOP的应用场景,知道AOP编程的重要性。这篇我们先看一段代码,来开始今天的学习。  回顾与上篇类似的代码:SecurityService类的IsPass判断用户名为“admin”...

Spring.NET学习笔记1——控制反转(基础篇)

在学习Spring.NET这个控制反转(IoC)和面向切面(AOP)的容器框架之前,我们先来看一下什么是控制反转(IoC)。  控制反转(Inversion of Control,英文缩写为IoC),...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)