Spring框架学习第二天

最新推荐文章于 2024-08-02 20:39:31 发布
最新推荐文章于 2024-08-02 20:39:31 发布
阅读量279 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring学习
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.youkuaiyun.com/CC_LIM/article/details/83830973
本文详细介绍了Spring框架中的组件扫描与装配机制，包括如何使用注解进行组件注册，组件装配的不同方式，以及如何利用Spring EL表达式进行值注入。同时，还深入探讨了自动装配、资源定位和组件生命周期管理的实现细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

bean参数的注入(简单数据的注入)

基本类型的数据和字符串
在配置文件applicationContext-DI1.xml注入简单的数据，例如String和一些基本数据类型

<bean id="msgBean" class="com.bean.MsgBean">
    <property name="title">
        <value>夜宵吃什么</value>
    </property>
    <property name="length" value="鱼香肉丝"></property>
</bean>
<bean id="msgBean2" class="com.bean.MsgBean">
    <property name="title">
        <null/>
    </property>
    <property name="length" value="null"></property>
</bean>

分别提供了三种注入方式

  1. 在property标签行内嵌入value属性:例如上面代码块的第5行
  2. 在property标签内嵌入value标签:例如上面代码块的第2行-第4行
  3. 在property标签内嵌入null标签:例如上面代码块的第8行-第10行

注入集合

通过<list/>,<set/>,<map/>及<props/>元素可以定义和设置与Java类型中对应List,Set,Map及Properties的属性值.

bean参数的注入(集合数据的注入)

Java中的List，对应配置文件中的标记

<property name="friends">
    <list>
        <value>逼哥</value>
        <value>马哥</value>
        <value>耀儿</value>
        <value>肖二狗</value>
    </list>
</property>

Java中的Set，对应配置文件中的标记

<property name="friends">
    <set>
        <value>逼哥</value>
        <value>马哥</value>
        <value>耀儿</value>
        <value>肖二狗</value>
    </set>
</property>

Java中的Map注入

<property name="phones">
    <map>
        <!--这样会出错-->
        <!--<entry>
            <key>马哥</key>
            <value>17608348340</value>
        </entry>-->
        <entry key="马哥" value="17608348340"></entry>
        <entry key="王牛逼">
            <value>17608348340</value>
        </entry>
    </map>
</property>

注入集合-Properties

注入Properties集合
Java中的Peoperties对应配置文件中的标记
例如：

<property name="delFriends">
    <props>
        <!--只能写key-->
        <prop key="小马哥1">111111</prop>
        <prop key="小马哥2">222222</prop>
        <prop key="小马哥3">333333</prop>
        <prop key="小马哥4">444444</prop>
        <prop key="小马哥5">555555</prop>
    </props>
</property>

装配一个对象dataSource对象

对象的单独定义以及使用类加载器location定义

<!--定义Peoperties对象，单独定义-->
<util:properties id="db2">
    <prop key="driverClassName">oracle.jdbc.OracleDriver</prop>
    <prop key="url">jdbc:oracle:thin:@localhost:1521:xe</prop>
    <prop key="username">system</prop>
    <prop key="password">123456</prop>
</util:properties>

<util:properties id="db" location="classpath:db.properties"></util:properties>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="#{db.driverClassName}"></property>
    <property name="url">
        <value>#{db.url}</value>
    </property>
    <property name="username" value="#{db.username}"></property>
    <property name="password" value="#{db.password}"></property>
</bean>

db.properties配置文件内容：

driverClassName=oracle.jdbc.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:xe
username=system
password=123456

TestBasicDataSourceGet.java内容：

public static void main(String[] args) throws SQLException {
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext-DI4.xml");
    DataSource dataSource = app.getBean("dataSource", DataSource.class);
    System.out.println(dataSource);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

Spring中的EL表达式

只要把之前的EL表达式中的$换成#就可以了

组件扫描

Spring提供了一套基于注解配置的使用方法。使用该方法可以大大简化XML配置信息。这个技术的出现可以极大的简化XML配置文件的编写。

使用方法如下：
在applicationContext.xml中添加启用标记`<context:component-scan base-package=“包路径”>``
在组件类中追加以下标记

注解标记描述
@Component通用注解
@Repository持久化层组件注解(dao)
@Service业务层组件注解
@Controller控制层组件注解

组件扫描的实现步骤

  1. 建立项目，拷贝IOC和AOP的jar包到lib下
  2. 拷贝配置文件到src下并在配置文件中开启组件扫描
    <context:component-scan base-package="包名结构" />
  3. 在相应的类上写下对应的标注
  4. 从Spring容器中获取对应的组件,默认是以类名首字母小写为标准获取组件的，当然也可以制定组件放入容器中的标识

例如，测试一下银行账户类(BankAccount)的配置及实际调用

  1. 建立项目，拷贝对应的jar包到lib下并配置Libraries，这里需要重要导入aop的jar包，如不导入会出现错误(什么错误？我也不知道，反正导入就不会出现错误)
  2. 设置配置文件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:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.bean"/>
</beans>

需要注意的是，在配置组件扫面的context标签中，需要设置注解标记，上面的表格都有哦，比如什么Component、Repository、Service、Controller
设置完了过后还需要配置包名，例如我们想要对bean包下的内容进行扫描注解，那么需要设置base-package="com.bean"，到此配置文件xml就结束了
3. 我创建了一个BankAccount类，内容如下：

package com.bean;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * Class Describe:银行账户
 *
 * @author biuaxia
 * @date 2018/11/7
 * @time 17:10
 */
@Component
public class BankAccount implements Serializable {
    private long id;
    /**
     * 卡号
     */
    private String cardNo;
    /**
     * 持卡人
     */
    private String accountName;
    /**
     * 密码
     */
    private String password;
    /**
     * 账户余额
     */
    private double money;


    @Override
    public String toString() {
        return "BankAccount{" +
                "id=" + id +
                ", cardNo='" + cardNo + '\'' +
                ", accountName='" + accountName + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                '}';
    }

    public BankAccount() {
        id = -1;
        cardNo = "0000 0000 0000 0000";
        accountName = "nnnn nnnn";
        password = "123456";
        money = 1.0;
    }

    public BankAccount(String cardNo, String accountName, String password, double money) {
        this.cardNo = cardNo;
        this.accountName = accountName;
        this.password = password;
        this.money = money;
    }

    public BankAccount(long id, String cardNo, String accountName, String password, double money) {
        this.id = id;
        this.cardNo = cardNo;
        this.accountName = accountName;
        this.password = password;
        this.money = money;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getCardNo() {
        return cardNo;
    }

    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }

    public String getAccountName() {
        return accountName;
    }

    public void setAccountName(String accountName) {
        this.accountName = accountName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public static void main(String[] args) {
    }

}

请注意，在类块儿上我们加上了注解@Component,因为在分析时，我们进行了判断，这个bean类属于持久化注解、业务层注解、控制层注解还是通用注解，经过考虑我选择了通用注解并加上了注释

从Spring容器获取中获取对应的组件

新建一个测试类，内容如下：

package com.test;

import com.bean.BankAccount;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Class Describe:
 *
 * @author biuaxia
 * @date 2018/11/7
 * @time 17:20
 */
public class ComponentScanTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("Component-Scan.xml");
        //获取银行账户对象
        BankAccount bankAccount = app.getBean("bankAccount", BankAccount.class);
        System.out.println(bankAccount);
    }
}

打印结果

结果图片

至此组件扫描从导入jar包 -> 创建bean对应的配置文件 -> 创建对应的bean类 -> 测试从Spring容器获取对应的组件 就完成了

集合的单独定义及引入

单独定义的用处在于有些数据需要多次调用的话，就不需要每次都在<property>中单独定义在调用了，增加复用性

props,list,set,map都可以被单独的抽取出去
如果要定义list，我们需要在<bean/>标签外定义,并且使用<util:list/>标签定义

  • <list/> -> <util:list/>
  • <set/> -> <util:set/>
  • <map/> -> <util:map/>
  • <properties/> -> <util:properties/>

记得给单独定义的集合加上id，在属性标签<property>使用ref属性来引用这个集合

在定义扫描对象时有三种方式

  1. @Component
  2. @Component("val")
  3. @Component(value="val")

这三种都可以哟

自定义测试组件扫描

文件结构如下
bean包:

  • com.bean.BankAccount
  • com.bean.MsgBean
    dao包
  • com.dao.BankAccountDAO
  • com.dao.BankAccountDAOImp
    test包
  • com.test.BeanAndDaoScanTest
  1. BankAccount仅在原有基础上加上了标注@Component
  2. MsgBean也一样只加了标注@Component
    3.配置文件BeanAndDaoScan.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:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.bean,com.dao"/>
</beans>
  1. 测试类BeanAndDaoTest
package com.test;

import com.bean.BankAccount;
import com.bean.MsgBean;
import com.dao.BankAccountDaoImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Class Describe:测试配置文件是否成功扫描
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 8:59
 */
public class BeanAndDaoScanTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        System.out.println("测试获取MsgBean对象:\t\t\t" + app.getBean("msgBean", MsgBean.class));
        System.out.println("测试获取BankAccount对象:\t\t" + app.getBean("bankAccount", BankAccount.class));
        System.out.println("测试获取BankAccountDaoImp对象:\t\t" + app.getBean("bankAccountDaoImp", BankAccountDaoImp.class));
        System.out.println("测试获取BankAccountDao对象:\t\t" + app.getBean("bankAccountDao", BankAccountDaoImp.class));

    }
}
结论

在测试类中，对bean包下的两个对象获取没有任何问题，其中获取时，我没有设置类的id，而是默认的配置@Component，这个时候获取就要使用类名首字母小写的方式获取Bean,在获取dao时出现问题，不能够获取到dao，但是可以获取实现类的对象，所以这里不能这样获取dao接口

自己写一个BankAccountDAO接口

定义一个根据卡号获取账户信息的方法，然后写一个实现类对这个方法做一个伪实现，最后把实现类对象以标注的形式加载到Spring容器中，最后通过Spring容器获取实现类对象并根据卡号获取对象的方法

文件结构如下：
bean包：
com.bean.BankAccount
dao包
com.dao.BankAccountDAO
com.dao.BankAccountDaoImp
test包
com.test.BeanAndDaoScanTest

  1. com.bean.BankAccount
package com.bean;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * Class Describe:银行账户
 *
 * @author biuaxia
 * @date 2018/11/7
 * @time 17:10
 */
@Component
public class BankAccount implements Serializable {
    private long id;
    /**
     * 卡号
     */
    private String cardNo;
    /**
     * 持卡人
     */
    private String accountName;
    /**
     * 密码
     */
    private String password;
    /**
     * 账户余额
     */
    private double money;


    @Override
    public String toString() {
        return "BankAccount{" +
                "id=" + id +
                ", cardNo='" + cardNo + '\'' +
                ", accountName='" + accountName + '\'' +
                ", password='" + password + '\'' +
                ", money=" + money +
                '}';
    }

    public BankAccount() {
        id = -1;
        cardNo = "0000 0000 0000 0000";
        accountName = "nnnn nnnn";
        password = "123456";
        money = 1.0;
    }

    public BankAccount(String cardNo, String accountName, String password, double money) {
        this.cardNo = cardNo;
        this.accountName = accountName;
        this.password = password;
        this.money = money;
    }

    public BankAccount(long id, String cardNo, String accountName, String password, double money) {
        this.id = id;
        this.cardNo = cardNo;
        this.accountName = accountName;
        this.password = password;
        this.money = money;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getCardNo() {
        return cardNo;
    }

    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }

    public String getAccountName() {
        return accountName;
    }

    public void setAccountName(String accountName) {
        this.accountName = accountName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public static void main(String[] args) {
    }

}
  1. com.dao.BankAccountDAO
package com.dao;

import com.bean.BankAccount;

/**
 * @author: gsdad
 */
public interface BankAccountDAO {
    /**
     * 获取账户信息的方法
     *
     * @param cardNo
     * @return
     */
    BankAccount getAccountByCardNo(String cardNo);
}
  1. com.dao.BankAccountDaoImp
package com.dao;

import com.bean.BankAccount;
import org.springframework.stereotype.Repository;

/**
 * Class Describe:
 *
 * @author biuaxia
 * @date 2018/11/7
 * @time 21:47
 */
@Repository("baDao")
public class BankAccountDaoImp implements BankAccountDAO {
    /**
     * 实现获取账户信息的方法
     */
    @Override
    public BankAccount getAccountByCardNo(String cardNo) {
        System.out.println("获取数据ing...");
        return null;
    }
}
  1. com.service.BankAccountService
package com.service;

import com.bean.BankAccount;
import com.dao.BankAccountDAO;
import org.springframework.stereotype.Service;

/**
 * Class Describe:
 *
 * @author biuaxia
 * @date 2018/11/7
 * @time 21:50
 */
@Service("baSer")
public class BankAccountService {
    private BankAccountDAO dao;
//    private BankAccountDAO dao = new BankAccountDaoImp();

    /**
     * 获取用户信息的service
     *
     * @return
     */
    public BankAccount getBankAccount(String cardNo) {
        return dao.getAccountByCardNo(cardNo);
    }
}
  1. com.test.BankAccountServiceTest
package com.test;

import com.service.BankAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Class Describe:测试能否拿到BankAccountService对象并调用实现方法
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 10:19
 */
public class BankAccountServiceTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        BankAccountService service = app.getBean("baSer", BankAccountService.class);
        System.out.println(service);
        service.getBankAccount("1234");
    }
}
  1. BankAccountTest.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:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.bean,com.dao,com.service"/>
</beans>

执行测试类的main方法，会出现空指针异常
Exception in thread "main" java.lang.NullPointerException

由此引入组件装配的标注内容

和组件装配有关的标注

  1. @Autowried/@Qualifier
  2. @Resource

其中，1可以处理构造器注入和Setter注入,2只能处理Setter注入，但大部分情况都是Setter注入

1还可以加在字段或者setter方法或者构造函数上面
首先根据类型加在对应的组件，类型找不到则根据名字查找，这个标注也可以指定名字进行查找，如果对应的名字都找不到就直接停止并且报错鸭
指定名字查找使用@Qualifier，自动匹配使用@Autowried
@Autowried(required=true)这是默认配合，则必须找到对应的组件，没有程序直接崩溃，也可以指定为false，找不到对应的组件就忽略了鸭

2@Resource可以加在字段或者setter方法，但这通常就够用了，这个标注他不是Spring框架的，它是Java中的标准标注，但可以和Spring无缝结合
@Resource优先按照名字查找，如果找不到则按照类型查找
当然也可以直接指定名字进行查找,注意了，指定名字必须使用@Resource(name = "baDao")这样的格式

其他标注

  1. @PostConstructor 初始化方法的标注
  2. @PreDestroy 对象销毁之前调用的标注
  3. @Value 可以使用Spring EL表达式注入值
    例子：
    扫描器配置好扫描路径就ok，不多写下来了~

Empbean类

package com.bean;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * Class Describe:员工类
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 11:40
 */
@Component
public class Emp {
    private String name;

    public Emp() {
        System.out.println("无参构造");
    }

    @PostConstruct
    public void init() {
        System.out.println("初始化？");
    }

    @PreDestroy
    public void destory() {
        System.out.println("我被销毁了？");
    }
}

TestEmp测试类

package com.test;

import com.bean.Emp;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Class Describe:
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 11:43
 */
public class TestEmp {
    public static void main(String[] args) {
//        ApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        AbstractApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        Emp emp = app.getBean("emp", Emp.class);
        System.out.println(emp);
        app.close();
    }
}

@Value的例子
配置文件BankAndDaoScab.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:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.bean,com.dao,com.service"/>
    <util:properties id="db2">
        <prop key="driverClassName">oracle.jdbc.OracleDriver</prop>
        <prop key="url">jdbc:oracle:thin:@localhost:1521:xe</prop>
        <prop key="username">system</prop>
        <prop key="password">123456</prop>
    </util:properties>
</beans>

Empbean类

package com.bean;

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

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * Class Describe:员工类
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 11:40
 */
@Component
public class Emp {
    @Value("#{db2.username}")
    private String name;
    @Value("#{db2.password}")
    private String pws;
    @Value("#{db2.url}")
    private String url;

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", pws='" + pws + '\'' +
                ", url='" + url + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPws() {
        return pws;
    }

    public void setPws(String pws) {
        this.pws = pws;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Emp() {
        System.out.println("无参构造");
    }

    @PostConstruct
    public void init() {
        System.out.println("初始化？");
    }

    @PreDestroy
    public void destory() {
        System.out.println("我被销毁了？");
    }
}

测试类TestEmp

package com.test;

import com.bean.Emp;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Class Describe:
 *
 * @author biuaxia
 * @date 2018/11/8
 * @time 11:43
 */
public class TestEmp {
    public static void main(String[] args) {
//        ApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        AbstractApplicationContext app = new ClassPathXmlApplicationContext("BeanAndDaoScan.xml");
        Emp emp = app.getBean("emp", Emp.class);
        System.out.println(emp);
        app.close();
    }
}

第二天的所有内容到此结束

2025最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 10万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
GSD_WeiXin（高仿微信）应用源码
weixin_30823833的博客
03-22 297
高仿微信计划：已经实现功能 1.微信首页（cell侧滑编辑、下拉眼睛动画、下拉拍短视频、点击进入聊天详情界面） 2.通讯录（联系人字母排序、搜索界面） 3.发现（朋友圈） 4.我（界面） 待实现功能（接下来一个月陆续完成） 1.语音搜索、发送短视频、地理位置等 2.朋友圈细节完善 3.扫一扫 4.相册、钱包 5.搭建服务器实现实时通信功能以及其他细节实现 部...
GSD文件简介
梦幻时空的博客
08-09 1万+
西门子的PLC采用GSD文件进行接口通信配置，使得不需要更改任何硬件的情况，可以满足客户的诸多需求。
Spring框架学习总结（上）
热门推荐
宜春
08-08 1万+
在学习SSM框架中，Spring框架我建议最好先学，平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们java中的类，当然也包括service dao里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字new。另外spring的aop，事务管理等等都是我们经常用到的，可见Spring的尤为重要的作用。 1.3.1Spring的概述 1.3.1.1什么...
springboot学习笔记第二天
最新发布
Word_seeker的博客
08-02 2434
AOP （Aspect Orient Programming）,直译过来就是面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交事务，并且在事务处理失败时，执行相应的回滚策略。
Spring基础框架 一 入门
小菜鸡的博客
07-30 858
Spring 入门 第一天
Spring框架及源码学习---手写IOC和AOP
weixin_43811057的博客
03-18 1052
Spring 是分层的 full-stack（全栈） 轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层 Spring MVC 和业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，已 经成为使⽤最多的 Java EE 企业应⽤开源框架。我们经常说的 Spring 其实指的是Spring Framework（spring 框架）。==IoC Inversion of Control (控制反转/反转控制)，注意它是⼀个技术思想，不是⼀个技术实现 ==
【spring框架技术】5天教你学会【第①天】
BLACK_Benny的博客
04-04 829
【spring框架技术】5天教你学会【第①天】
Spring学习：学完总结
H215919719的博客
12-10 1049
（1）全称：EJB(sun企业级开发框架)-->S(Spring)S(struts2)H(hibreate) -->S(spring)S(springmvc)M(mybatis)（2）所以Spring到底是什么？Spring不是某一层的框架, 针对各层的解决方案的框架, 提供了一站式开发, 其他框架,只需要与spring整合, Spring管理整个项目的bean(java对象), 在需要使用每个bean的时候, 找spring, 由spring把需要的bean注入给你, 每一层的解耦。1.依赖注入。
Spring框架第一天(入门，编写配置文件)
dml111727
11-01 1572
Spring框架第一天Spring框架的学习路线1. Spring第一天：Spring的IOC容器之XML的方式，Spring框架与Web项目整合 2. Spring第二天：Spring的IOC容器之注解的方式，Spring的AOP技术 3. Spring第三天：Spring的事务管理、Spring框架的JDBC模板 4. Spring第四天：SSH三大框架的整合 今天内容概述1. Spring框架
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第二天
10-29
Spring 框架学习资料第二天 本篇文章主要讲解了 Spring 框架的第二天学习资料，涵盖了 FactoryBean、Spring 工厂配置文件的参数化、静态代理、AOP 开发等知识点。 一、FactoryBean FactoryBean 是 Spring 框架中...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第三天
10-29
Spring框架学习资料第三天 Spring框架是2003年兴起的一门轻量级的JAVAEE框架技术。 Spring框架学习资料第三天主要涵盖了AOP、Spring动态代理的实现原理、SM整合（Spring+Mybatis）等知识点。 一、AOP（面向切面...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第四天
10-29
"Spring框架学习资料第四天：事务控制" Spring框架是2003年兴起的一门轻量级的JAVAEE框架技术。本文主要介绍Spring框架中的事务控制机制，涵盖了事务的基本概念、JDBC和Mybatis中的事务控制、Spring中的事务控制...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第一天
10-29
Spring框架学习资料第一天 一、Spring框架简介 * Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 * Spring框架的诞生目的是致力于全面的简化JAVAEE企业级应用的开发 * Spring框架采用了很多的设计模式：...
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第五天
10-29
Spring框架，作为2003年崛起的一款轻量级...通过以上学习，你可以深入理解Spring框架的核心特性，掌握如何利用注解进行事务管理和开发，以及如何进行SSM集成和单元测试。不断实践将有助于提升你的Spring开发技能。
使用Spring框架+前端技术实现简易的留言系统
gsdad_white的博客
11-23 3133
文章目录提要阅读准备数据库的简易构建带数据的数据库结构sql语句创建序列创建表及导入数据导入后的数据后端代码实现首先配置Spring框架文件SpringMvc.xmlSpringDao.xmlweb.xml书写主要逻辑编写dao接口：UserDao编写dao接口实现类：UserDaoImpl编写bean类：Commit编写对应RowMapper类：CommitRowMapper编写对应控制器：Us...
Spring框架学习第七天
gsdad_white的博客
11-20 557
文章目录SpringMVC + Ajax 技术Ajax异步的处理同步处理总结使用@ResponseBody常见错误验证码校验自动根据浏览器请求头`Content-Language`国际化按用户选择的语言环境显示文字运行效果图 SpringMVC + Ajax 技术 Ajax Ajax技术特点：异步请求、局部刷新 同步模式：请求1-&amp;gt;响应1-&amp;gt;请求2-&amp;gt;响应2 异步模式：请求1-&amp;...
【补充】Spring 第一天 DI注入的三种方式和数据的装配方式
gsdad_white的博客
11-13 532
文章目录哪三种方式？准备工作使用构造器注入如果构造函数存在多个参数时，怎么处理？使用type属性指定参数的类型需要给参数指定一个引用（指向其他bean），使用ref属性使用setter注入使用自动装配注入的内容（装配数据）1）参数值注入2）注入集合注入Spring表达式注入空字符串或者null 哪三种方式？ 使用构造器注入 使用setter注入 使用自动装配 准备工作 配置文件spring-...
Spring框架学习第一天
gsdad_white的博客
11-06 430
第一天 - 简单配置及DI的注入 1.spring 框架构成 核心部分 IOC(控制反转) 基础部分 整个spring框架的基石 Spring DAO Spring 对 jdbc 的支持 Spring web Mvc spring 规范web mvc的开发 后期还要集成其它框架 Spring AOP 面向切面编程 Spring ORM(对象关系映射) spr...
Spring框架入门第一天学习笔记
知识点二：Spring框架的主要特性 1. 轻量级：Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。它通过控制反转减少了代码的耦合，并通过面向切面编程，可以将应用中的交叉问题从业务逻辑中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值