Spring 的IOC 和Aop

Spring 的IOC 和Aop

在ApplicationContext.xml中,bean的scope属性默认是singleton,即默认是单例

Spring容器创建的时候,会将所有的配置的bean对象创建,默认bean都是单例的,

代码通过getBean()方法从容器获取指定的bean实例,容器首先会调用Bean类的无参构造器,创建实例对象

bean的作用域

scope=“prototype” 原型模型(N个对象),真正使用时才会创建,没获取一次,都会创建不同的对象

scopr="singleton" 单例模式:容器初始化时就会初始化所有的bean对象,,每次获取的都是同一个对象,默认值

多种方式实现依赖注入

设置注入

<bean id="user3" class="cn.hmy.bean.User">
       <property name="username ">
         <value><![CDATA[P&g]]></value>
       </property>
     </bean> 

构造注入

注意:

1、一个<constructor-arg>元素表示构造方法的一个参数,且使用时不区分顺序。

2、通过<constructor-arg>元素的index 属性可以指定该参数的位置索引,位置从0 开始。

3、<constructor-arg>元素还提供了type 属性用来指定参数的类型,避免字符串和基本数据类型的混淆。

<bean id="user" class="cn.hmy.bean.User" scope="prototype">
      <constructor-arg index="0" type="java.lang.String" value="lxl"/>
      <constructor-arg index="1" type="java.lang.String" value="[email protected]"/>
      <constructor-arg index="2" type="cn.hmy.bean.Car" ref="car"></constructor-arg>
    </bean>

p命名空间注入

xmlns:p="http://www.springframework.org/schema/p"....<!--p命名空间注入 -->
    <bean id="user2" class="cn.hmy.bean.User" p:username="张嘎" p:password="123"/>

c命名空间的注入

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

<!--c命名空间注入  -->
    <bean id="user5" class="cn.hmy.bean.User" c:car-ref="car" c:username="岁月静好" c:password="123"/>

引用其他bean组件

<!--引用其他的Bean组件   即给域属性的赋值-->
     <bean id="car" class="cn.hmy.bean.Car">
       <property name="color" value="白色"/>
     </bean>

     <bean id="user4" class="cn.hmy.bean.User">
       <property name="car" ref="car"/>
     </bean>

注入不同数据类型

 <!-- 注入集合类型的属性 -->
     <!-- 注入list类型的属性 -->
     <bean id="collectionBean1" class="cn.hmy.bean.CollectionBean">
       <property name="names">
         <list>
            <value>张三</value>
            <value>李四</value>
         </list>
       </property>
     </bean>

     <!--注入set类型的属性  -->
     <bean id="collectionBean2" class="cn.hmy.bean.CollectionBean">
       <property name="address">
         <set>
            <value>张三2</value>
            <value>李四2</value>
         </set>
       </property>
     </bean>

     <!--注入map类型的属性  -->
     <bean id="collectionBean4" class="cn.hmy.bean.CollectionBean">
       <property name="map">
         <map>
          <entry>
            <key><value>football</value></key>
            <value>足球</value>
          </entry>
         </map>
       </property>
       </bean>

     <!--注入properties类型的属性  -->
     <bean id="collectionBean5" class="cn.hmy.bean.CollectionBean">
       <property name="pro">
         <props>
           <prop key="basketball">篮球</prop>
         </props>

       </property>

     </bean>

     <!--给数组注入值  -->
    <bean id="collectionBean6" class="cn.hmy.bean.CollectionBean">
      <property name="strs">
        <list>
          <value>神奇</value>
          <value>神奇</value>
          <value>神奇</value>
        </list>
      </property>
    </bean>

使用注解实现注入

package cn.hmy.bean;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

//@Component("info")  不分层
//@Repository("info") dao
//@Controller("info") action
@Service("info")   // biz
public class User {

    @Value("岁月静好")  //普通属性
    private String username; // 用户名
    @Value("123")
    private String age; // 密码
    //@Resource  域属性
    @Autowired //域属性
    private Car myCar;

    public Car getMyCar() {
        return myCar;
    }

    @Override
    public String toString() {
        return "User [username=" + username + ", age=" + age + ", myCar="
                + myCar + "]";
    }

    public void setMyCar(Car myCar) {
        this.myCar = myCar;
    }
    public User() {
        System.out.println("init user");
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }

}
<?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"> <!-- bean definitions here -->

   <context:component-scan base-package="cn.hmy.bean"/>

</beans> 
package cn.hmy.bean;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class Car {

    @Value("白色")
    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car [color=" + color + "]";
    }

}
时间: 2024-10-06 22:28:39

Spring 的IOC 和Aop的相关文章

spring的IOC和AOP详细讲解

1.解释spring的ioc? 几种注入依赖的方式?spring的优点? IOC你就认为他是一个生产和管理bean的容器就行了,原来需要在调用类中new的东西,现在都是有这个IOC容器进行产生,同时,要是产生的是单例的bean,他还可以给管理bean的生命周期! spring的IOC有三种注入方式 : 第一是根据属性注入 也叫set方法注入: 第二种是根据构造方法进行注入: 第三种是根据注解进行注入,这种方式我认为比较好,方便,要是bean多的话,使用前两种方式会使得配置文件过于臃肿. Spri

Spring入门IOC和AOP学习笔记

Spring入门IOC和AOP学习笔记 概述 Spring框架的核心有两个: Spring容器作为超级大工厂,负责管理.创建所有的Java对象,这些Java对象被称为Bean. Spring容器管理容器中Bean之间的依赖关系,使用一种叫做"依赖注入"的方式来管理bean之间的依赖关系. Spring有两个核心接口:BeanFactory和ApplicationContext,ApplicationContext是BeanFactory的子接口.它们都可以代表Spring容器,Spri

spring的IOC和AOP

spring的核心就是IOC和AOP. IOC(控制反转)和DI(依赖注入)是同一个概念.具体的讲:当某个角色需要另外一个角色协助的时候,在传统的程序设计过程中,通常由调用者来创建被调用者的实例.但在spring中 创建被调用者的工作不再由调用者来完成,因此称为控制反转.创建被调用者的工作由spring来完成,然后注入调用者因此也称为依赖注入.所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B,反正A要用到B,则A依赖于B.举个生活中的例子:通常情况下,假如你有一天在家里口渴了

Spring的IOC和AOP之深剖

我们首先要知道 用Spring主要是两件事: 1.开发Bean:2.配置Bean.对于Spring框架来说,它要做的,就是根据配置文件来创建bean实例,并调用bean实例的方法完成“依赖注入”. Spring框架的作用是什么?有什么优点? 1.降低了组件之间的耦合性 ,实现了软件各层之间的解耦 2.可以使用容易提供的众多服务,如事务管理,消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术,利用它很容易实现如权限拦截,运行期监控等功能 5.容器提供了众多的辅助类,能加快应用的开发 6

spring的IOC和AOP协同工作

看网络上的spring资料,基本都是在讲解IOC和AOP,但是二者是如何协同工作的,说的很少. 粗略调试了下BeanFactory的创建过程,发现是如图所示的大概过程.其中BeanPostProcessor是关键. 在目标对象实例化完成后,通过AOP相关的BeanPostProcessor,检查实例是否需要增加AOP,需要的话,就按照网络中大多数资料中讲解的流程,创建代理实例,并将代理实例,增加到缓存中,这样再次获取指定Bean时,就会获得已增加AOP的代理实例. 如果有错误之处,还请指出.

SSH整合 第四篇 Spring的IoC和AOP

这篇主要是在整合Hibernate后,测试IoC和AOP的应用. 1.工程目录(SRC) 2.IoC 1).一个Service测试类 1 /* 2 * 加入spring容器 3 */ 4 private ApplicationContext applicationContext = 5 6 new ClassPathXmlApplicationContext("classpath:spring/applicationContext.xml"); 7 public static void

Spring中IOC和AOP的详细解释

我们是在使用Spring框架的过程中,其实就是为了使用IOC,依赖注入,和AOP,面向切面编程,这两个是Spring的灵魂. 主要用到的设计模式有工厂模式和代理模式. IOC就是典型的工厂模式,通过sessionfactory去注入实例. AOP就是典型的代理模式的体现. 代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对

对Spring中IOC和AOP的理解

IOC:控制反转也叫依赖注入.利用了工厂模式. 为了方便理解,分解成每条以便记忆.  1.将对象交给容器管理,你只需要在spring配置文件总配置相应的bean,以及设置相关的属性,让spring容器来生成类的实例对象以及管理对象.2.在spring容器启动的时候,spring会把你在配置文件中配置的bean都初始化好,3.在你需要调用的时候,就把它已经初始化好的那些bean分配给你需要调用这些bean的类(假设这个类名是A),分配的方法就是调用A的setter方法来注入,而不需要你在A里面ne

面试之Spring框架IOC和AOP的实现原理

IoC(Inversion of Control) (1). IoC(Inversion of Control)是指容器控制程序对象之间的关系,而不是传统实现中,由程序代码直接操控.控制权由应用代码中转到了外部容器,控制权的转移是所谓反转. 对于Spring而言,就是由Spring来控制对象的生命周期和对象之间的关系:IoC还有另外一个名字--"依赖注入(Dependency Injection)".从名字上理解,所谓依赖注入,即组件之间的依赖关系由容器在运行期决定,即由容器动态地将某