Spring（二、Spring IOC）

最新推荐文章于 2017-10-23 13:30:33 发布
最新推荐文章于 2017-10-23 13:30:33 发布
阅读量217 收藏
点赞数
分类专栏： javaweb 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_c_/article/details/78310991
版权

一、Spring的IOC操作

1、把对象的创建交给spring进行管理
2、ioc的操作有两部分操作：
    （1）ioc里基于配置文件的方式实现
    （2）ioc里基于注解的方式实现
3、ioc的底层原理里主要使用的技术
    （1）xml配置文件
    （2）dom4j解析xml
    （3）工厂设计模式
    （4）反射

二、IOC操作（基于XML）

案例：

1、普通的方法调用过程

package com.test;
public class User {
    public void hello() {
        System.out.println("hello...");
    }

    public static void main(String[] args) {
        //原始调用方法
        User user = new User();
        user.hello();
    }
}

2、使用SpringIOC 调用方法的过程

1、创建项目，导入Spring基本的jar包和commons-logging.jar包
注意：需要同时导入commons-logging.jar包，否则会报错

这里写图片描述

2、创建spring的配置文件并配置创建的类

（1）spring核心配置文件的名称和位置不是固定的。可以创建多个配置文件。
    建议放到src目录下（方便获取），名称没有要求。官方建议名称applicationContext,xml
（2）在配置xml文件里，引入schema约束。

配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
                  http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置对象  -->
    <bean id="user" class="com.test.User"></bean>


3、调用：

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User bean = (User) context.getBean("user");
bean.hello();

四、bena标签的常用属性

id    ：起名称，id属性值名称无要求，可任意命名，用来在项目中查找此bean对象。
           --id属性值：不能写中文，不能包含特殊的符号。
class ：创建对象类的全路径。
name  ：功能和id值一样，id属性值不能包含特殊符号，name中可以包含特殊符号。为了兼容旧版（已弃用）
scope ：表示创建的对象的特点。
       singleton：默认的，对象是单例。
       prototype：多例的。

request：web项目中，Spring创建一个bean对象，将对象存入到request域中。
session：web项目中，Spring创建一个bean对象，将对象存入到session域中。
globalSession：web项目中，应用在prolet环境，如果没有prolet环境，那么globalSession相当于session。

五、属性注入介绍

属性注入：在创建对象的时候，对对象的属性设置值。

java代码中，属性注入的方式：
（1）有参构的造方式
（2）使用set方式注入
（3）使用接口注入

Spring框架中，只支持set方法注入和有参数的构造注入。

1、使用有参构造注入属性

package com.test;

public class Bean1 {
    private String userName;

    public Bean1(String userName) {
        super();
        this.userName = userName;
    }

    public void output() {
        System.out.println("userName: " +userName);
    }
}

配置文件配置参数注入：

<!--使用有参构造注
入属性  -->
<bean id="bean1" class="com.test.Bean1">
    <!--name:属性名    value：属性值  -->
    <constructor-arg name="userName" value="spring"></constructor-arg>
</bean>

2、使用set方法注入属性（常用）

package com.test;

public class Bean2 {
    private String userName;

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public void output() {
        System.out.println("userName: " +userName);
    }
}

配置文件配置参数注入：

<!--使用set方法注入属性  -->
<bean id="bean2" class="com.test.Bean2">
    <!--name:类里面定义的属性名  value：设置的属性值  -->
    <property name="userName" value="spring"></property>
</bean>

3、注入对象类型属性（重点）
1、创建service类和dao类。
（1）在service中得到dao的对象。
1、在service里，把dao作为一个属性。
2、生成dao的set方法。

package com.test;

public class Dao {
    public void output() {
        System.out.println("dao output....");
    }
}

package com.test;

public class Service {
    private Dao userDao;


    public Dao getUserDao() {
        return userDao;
    }

    //创建set方法，通过set方法注入值。
    public void setUserDao(Dao userDao) {
        this.userDao = userDao;
    }


    public void output() {
        userDao.output();
        System.out.println("service output....");
    }
}

<!--配置service 和dao对象  -->
<bean id="dao" class="com.test.Dao"></bean>
<bean id="service" class="com.test.Service">
    <!-- ref：引用，要注入哪一个对象，写bean标签的id值 -->
    <property name="userDao" ref="dao"></property>
</bean>
//调用输出
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Service bean = (Service) context.getBean("service");
bean.output();

输出结果：
这里写图片描述

六、注入复杂类型属性

package com.test;

import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.junit.Test;

public class Bean3 {
    private String[] arrs;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;

    public String[] getArrs() {
        return arrs;
    }
    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }
    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Test
    public void output (){
        System.out.println("arrs: " +arrs);
        System.out.println("list: " +list);
        System.out.println("map: " +map);
        System.out.println("properties: " +properties);
    }

}

配置文件配置属性值：

<bean id="bean3" class="com.test.Bean3">
    <!--数组  -->
    <property name="arrs">
        <list>
        <value>wanna</value>
        <value>luna</value>
        <value>chen</value>
        <value>shiki</value>
        </list>
    </property>

    <!--list -->
    <property name="list">
        <list>
            <value>guangzhou</value>
            <value>shenzhen</value>
            <value>zhongshan</value>
        </list>
    </property>

    <!--map -->
    <property name="map">
        <map>
        <entry key="aa" value="AA"></entry>
        <entry key="bb" value="BB"></entry>
        <entry key="cc" value="CC"></entry>
        </map>
    </property>

    <!--properties  -->
    <property name="properties">
        <props>
            <prop key="driverclass">com.mysql.jdbc.driver</prop>
            <prop key="username">root</prop>
            <prop key="userpassword">root</prop>
        </props>
    </property>
</bean>

调用输出：

//调用输出
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Bean3 bean = (Bean3) context.getBean("bean3");
bean.output();

输出结果：
这里写图片描述

七、IOC操作（注解）

1、注解介绍
注解：代码里面的特殊标记，使用注解可以直接完成相关功能。
注解的写法：@注解名称（属性名称=属性值）。如果只有一个属性，则可以省略属性名称 ：@注解名称（属性值）
注解使用范围：可以使用在类方面，方法上面，属性上面。

Spring的bean管理（注解）
（1）使用注解创建对象
（2）使用注解注入属性
（3）xml和注解方式混合使用

2、注解创建对象
（1）导入Spring基本jar包和aop包
这里写图片描述
(2)引入注解相关约束

xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd"

(3)xml配置，开启注解扫描

<!--开启注解扫描，到包里面扫描类、方法、属性上是否有注解
    base-package:扫描的类所在的包名，多个包名之间用逗号隔开
    如果有com.test.test1,com.test.test2两个包，则用com.test作为base-package的值也可以
  -->
<context:component-scan base-package="com.test"></context:component-scan>

<!--只扫描属性上的注解  -->
<context:annotation-config></context:annotation-config>

(4)注解创建对象

package com.test;

import org.springframework.stereotype.Component;

@Component(value="bean4") //等同于 <bean id="bean4" class="com.test.Bean4"> </bean>
public class Bean4 {

    public void output() {
        System.out.println("bean4 output....");
    }
}

(5)输出

//调用输出
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Bean4 bean = (Bean4) context.getBean("bean4");
bean.output();

创建对象有四个注解：
Spring中提供@component的三个衍生注解：（功能目前来讲是一致的，都创建对象）

@Controller ：web层
@Service    ：业务层
@Repository ：持久层

这三个注解是为了让标注类本身的用途清晰

创建对象是单实例还是多实例（scope注解）：

@Component(value="bean4") //等同于 <bean id="bean4" class="com.test.Bean4"> </bean>
@Scope(value="prototype") //prototype:多例的 不填写默认为singleton：单例
public class Bean4 {

    public void output() {
        System.out.println("bean4 output....");
    }
}

3、注解注入属性
注入属性：@Autowired、@Resource（name=”“)，这两种方式都可以实现注入属性。使用resource需要指定name值，name值为UserDao的注解的value值。
Bean4.java

package com.test;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value="bean4") //等同于 <bean id="bean4" class="com.test.Bean4"> </bean>
@Scope(value="prototype") //prototype:多例的 不填写默认为singleton：单例
public class Bean4 {

    public void output() {
        System.out.println("bean4 output....");
    }
}

Bean5.java

package com.test;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller("bean5")
public class Bean5 {

//  @Autowired
    @Resource(name="bean4")
    private Bean4 bean4;

    public void output () {
        bean4.output();
        System.out.println("bean5 output...");
    }

}

调用：

//调用输出
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Bean5 bean = (Bean5) context.getBean("bean5");
bean.output();

输出结果：
这里写图片描述

4、注解和配置文件混合使用

1、创建对象操作使用配置文件方式实现。
2、注入属性的操作使用注解的方式实现。

Bean4.java

public class Bean4 {
    public void output() {
        System.out.println("bean4 output....");
    }
}

Bean5.java

public class Bean5 {

//  @Autowired
    @Resource(name="bean4")
    private Bean4 bean4;

    public void output () {
        bean4.output();
        System.out.println("bean5 output...");
    }

}

配置文件：

    <bean id="bean4" class="com.test.Bean4"></bean>
    <bean id="bean5" class="com.test.Bean5"></bean>

调用：

//调用输出
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Bean5 bean = (Bean5) context.getBean("bean5");
bean.output();

输出结果：
这里写图片描述

chensp_
关注
专栏目录
springIoc实现原理
04-20
**二、Spring Ioc容器** Spring Ioc容器是整个Spring框架的基石，它负责创建、配置和管理对象。容器通过读取XML、Java注解或Java配置类等方式，获取对象的定义信息，然后根据这些信息实例化对象并进行依赖注入。 *...
Spring中IoC优点与缺点解析
08-28
Spring 中 IoC 优点与缺点解析 IoC(Inversion of Control)是 Spring 框架中的一种设计模式，它的主要思想是将对象的创建和管理交给容器，从而解耦合对象之间的依赖关系。今天，我们将详细解析 IoC 的优点和缺点。 ...
二,Spring IOC以及整合
最新发布
01-13
**Spring IOC（Inversion of Control）与DI（Dependency Injection）** Spring 框架的核心特性是IOC（控制反转）和DI（依赖注入），这两个概念在Java应用开发中扮演着至关重要的角色。首先，理解什么是控制反转。...
SPRING IOC注入方式过程解析
08-25
SPRING IOC注入方式过程解析 SPRING IOC是一种轻量级的控制反转（Inversion of Control）容器框架，主要用于解耦合Java应用程序中的组件。其中，IOC（Inversion of Control）注入是SPRING IOC的核心机制之一。下面...
spring_ioc
06-04
这是spring_ioc部分的内容。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
MySql（一、MySQL基础、库操作和表操作）
csdn_c_的博客
10-21 659
MySQL数据库MySQL数据库是一种C/S结构的软件：客户端/服务端，若想访问服务器，必须通过客户端（服务器一直运行，而客户端在需要使用的时候运行。）交互方式： 1、客户端连接认证：连接服务器，认证身份：mysql.exe -hPup 2、客户端发送SQL指令 3、服务器接收SQL指令，处理SQL指令，返回操作结果。 4、客户端接收结果：显示结果。 5、断开连接（释放资源：服务器并发限制）：退出的
MySql（三、列操作和数据类型）
csdn_c_的博客
10-21 637
列类型数据类型：对数据进行统一的分类，从系统的角度出发，为了能够使用统一的方式进行管理，更好的利用有限的磁盘空间。SQL中将数据类型分成了三大类：1、数值类型 2、字符串类型 3、时间日期类型 1、数值型 数值型数据：都是数值，系统将数值型分为整数型和小数型。 SQL种的数据类型全部都是默认有符号：分正负。整数型：存放整型数据，在SQL中更多要考虑如何节省空间，所以系统将整型又细分成了5类：ti
数据库基础
csdn_c_的博客
10-21 485
一、什么是数据库数据库：高效的存储和处理数据的介质（介质主要是两种：磁盘和内存）二、数据库分类数据库基于存储介质的不同 关系型数据库（SQL）和非关系型数据库（Not Only SQL）关系型数据库：大型：oracle， DB2 中型：SQL-SERVER，Mysql 小型：access等 非关系型数据库：memcached，mongodb，redis（同步到磁盘） 两种数据库的区别： 关系型数
JDBC(一 JDBC的基本操作CRUD)
csdn_c_的博客
10-22 393
一、JDBCSpringJDBC 是Spring提供的持久层技术二、配置JDBC环境1、导入Spring核心开发包Spring-bean Spring-context Spring-core Spring-expression 2、导入Commons-logging日志包commons-logging. 3、导入JDBC模板开发包spring-jdbc spring-tx 三、JDBC 执行CRUD
SpringMVC（一、SpringMVC基础）
csdn_c_的博客
10-23 321
一、什么是SpringMVC？SpringMVC是spring框架的一个模块,SpringMVC和Spring无需通过中间层进行整合。 SpringMVC是基于mvc的web框架。Spring的框架结构图： 二、什么是MVCmvc：是一个设计模式 mvc在b/s系统下的应用： 三、SpringMVC架构原理分析SpringMVC的框架： 处理器映射器（handlerMapping）：根据请
MySQL（二、字符集校对集）
csdn_c_的博客
10-21 273
字符集：计算机只识别二进制，人类更多是识别符号。需要有个二进制与字符的对应关系。这个对应关系就是字符集。--查看服务器到底识别哪些字符集： show character set;--查看服务器默认的对外处理的字符集： show variables like ‘character_set%’;其中：client：服务器默认的客户端来的数据的字符集 connection：连接层字符集，是字符集转变的中间
JSP（一）
csdn_c_的博客
10-21 268
jsp
Servlet（一）
csdn_c_的博客
10-21 263
servlet
SpringBoot（一、入门）
csdn_c_的博客
10-23 246
一、SpringBoot介绍Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”. We take an opinionated view of the Spring platform and third-party lib
Spring（一、Spring的相关概念）
csdn_c_的博客
10-22 232
Spring的相关概念1、Spring是开源的轻量级框架（轻量级：框架使用不依赖很多其他东西，可以直接使用） 2、Spring核心主要两部分：（1）AOP（Aspect oriented Programming）：面向切面编程，扩展功能不是通过修改源代码实现。 （2）IOC（Inversion of Control）：控制反转 --比如有一个类，在类里面有一个方法（不是静态的方法），调用类
Http协议
csdn_c_的博客
10-21 218
http协议
web学习路线
csdn_c_的博客
10-21 216
学习路线
Spring(三、Spring AOP）
csdn_c_的博客
10-22 203
一、概念AOP（Aspect Oriented Programming）概念：面向切面（方面）编程，扩展功能，不是通过修改源代码实现。AOP采用横向抽取机制，取代了传统纵向集成体系重复性代码（性能监视、事务管理、安全检查、缓存）。 SpringAOP使用纯java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标植入增强代码。AspectJ是一个基于java语言的AOP框架，Spri
Spring IoC容器深度解析
"《Spring揭秘》精选版，主要讲解了Spring的IoC容器，由王福强著，书中深入探讨了IoC（Inversion of Control，控制反转）的基本概念、IoC服务提供者以及Spring的BeanFactory。" Spring的IoC容器是Spring框架的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值