SSM使用说明
一.Mybatis使用说明
工具: 不需要tomcat服务器,只需要数据库
xml配置: 只需要写domain类和dao接口,不需要写接口实现类,在resource目录下写sqlconfigmap.xml,里面配置数据库驱动链接,typelias标签里配置domain的路径,以达到简写目的,在写set标签,里面配置dao接口和dao接口配置文件的路径,以达到简写目的;dao接口写的是抽象方法,dao接口的配置文件,里面写的是sql语句,其中sql语句的id对应的是dao接口的抽象方法名。然后就可以写测试类,里面配置好sql对象,factory工厂。
注解配置: 只需要写domain类和dao接口,在resource目录下写sqlconfigmap.xml,里面配置数据库驱动链接,typelias标签里配置domain的路径,以达到简写目的,在写set标签,里面配置dao接口的路径,以达到简写目的;不需要写接口实现类;dao接口写的是抽象方法,然后再抽象方法上写sql语句。然后就可以写测试类,里面配置好sql对象,factory工厂。
扩展: 上面的配置都是基本配置,可以实现单表查询,但对于多对一,一对多,多对多,缓存,还需要在类,接口方法,配置文件,上做额外的配置。
延迟加载: 适用于一对多,多对多,在sqlmap开启延迟加载开关,dao.xml文件需要你修改result,然后修改一对多查询语句,同时添加一句根据id查询账户信息的语句,两者搭配使用,不然之前一对多的查询,直接把两个表都查询了,这样就没法使用延迟加载,注意UserDao接口也要多写一句根据id查询账户信息的方法。当然你想让多对一,一对一也实现同样方法的话,也只需设置同样的配置即可。
缓存: 一级缓存sqlSession对象mybatis给我们实现了,不用管,二级缓存SqlSessionFactory需要我们自己设置,但是SqlSessionFactory只是存放数据,不存放sqlSession对象,所以打印的数据一样,但是两个数据对象不相等,因为对象地址不一样。二级缓存需要在sqlmap配置缓存开关,然后在需要缓存机制的dao.xml文件里开启cache()
注解实现全功能: 既简单也实现了延迟加载和缓存,就是UserDao接口填写缓存注解配置时,太棒了。但是注意UserDao借口开启的缓存注解会跟一对多查询语句冲突。
二.Spring使用说明
1.基于xml的ioc入门
1.导入spring-context 5.2.13.RELEASE,里面就包含了bean,core,expression,还有aop,jcl依赖,是个不简单的依赖。
2.建一个bean.xml(名字可以随便起,但因为使bean对象,最好起bean)文件,里面传入xmlns约束(打开https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core网址,按ctrl+f,搜索xmlns)
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
3.在bean文件里写bean标签,把对象的创建交给spring来管理
<bean id="accountServive" class="ioc_xml.service.impl.AccountServiceImpl"></bean>
<bean id="accountDao" class="ioc_xml.dao.impl.AccountDaoImpl"></bean>
4.模拟表现层(用来调用业务层)
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
/**
* 获取spring的ioc核心容器,并根据id获取对象
* ApplicationContext的三个常用实现类:
* ClassPathXmlApplicationContext:它可以加载类路径下的配置文件,要求配置文件必须在类路径下。不在的话,加载不了(相比较下面一个,这个更常用)
* FileSystemXmlApplicationContext:他可以加载磁盘任意路径下的配置文件(必须有访问权限)
* AnnotationConfigApplicationContext:用于读取注解创建的容易内容
*
* 核心容器的两个接口引发的问题
* ApplicationContext:单例对象适用。但ApplicationContext接口很智能,能够根据对象是单例或多例来采取是延迟加载还是立即加载的方式,所以更偏向采用此接口
* 他在构建核心容器时,创建对象采取的策略是立即加载的方式,也就是说,一读取完配置文件,马上就采用反射的方式,创建配置文件中配置的对象
* BeanFactory: 多例对象适用
* 他在构建核心容器时,创建对象采取的策略是延迟加载的方式,也就是说,什么时候根据id获取对象了,什么时候才真正的创建对象
* @param args
*/
public static void main(String[] args) {
//采用ApplicationContext创建对象,也是演示ApplicationContext创建对象的过程
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
// ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");
//2.根据id获取Bean对象
IAccountService is=(IAccountService)ac.getBean("accountServive");//把object对象,强转成IAccountService对象
IAccountDao iad=ac.getBean("accountDao",IAccountDao.class);//通过字节码强转得到我们想要的对象
System.out.println(is);
System.out.println(iad);
//演示BeanFactory创建对象过程
/* Resource resource=new ClassPathResource("bean.xml");
BeanFactory factory=new XmlBeanFactory(resource);
IAccountService is=(IAccountService)factory.getBean("accountServive");
System.out.println(is);*/
}
}
2.Spring 基于 XML 的 IOC 细节[掌握]
2.1 IoC(控制反转转-Inversion Of Control) 的概念和作用
通过 Spring 提供的 IoC 容器,可以将对象间的依赖关系交由 Spring 进行控制,避免硬编码所造成的过度程序耦合。(用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用)。耦合指的就是就是对象之间的依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。 **工厂模式解耦:**在实际开发中我们可以把三层的对象都使用配置文件配置起来,当启动服务器应用加载的时候,让一个类中的方法通过读取配置文件,把这些对象创建出来并存起来。在接下来的使用的时候,直接拿过来用就好了。那么,这个读取配置文件,创建和获取三层对象的类就是工厂。 以前我们在获取对象时,都是采用 new 的方式。是主动的。现在:我们获取对象时,同时跟工厂要,有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转,它是 spring 框架的核心之一。
spring 中工厂的类结构图
BeanFactory 和 ApplicationContext 的区别
BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别:
创建对象的时间点不一样。
ApplicationContext:只要一读取配置文件,默认情况下就会创建对象。
BeanFactory:什么使用什么时候创建对象。
ApplicationContext 接口的实现类
ClassPathXmlApplicationContext:它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext:它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解
2.2 bean 标签和管理对象细节
实例化 Bean对象 的三种方式
第一种方式:使用默认无参构造函数
在默认情况下:它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数,将会创建失败。
第二种方式:spring 管理实例工厂-使用实例工厂的方法创建对象 (模拟一个工厂类,这个类可能是存在于jar中,我们无法通过修改源码的方式来提供默认构造函数)
/**
* 模拟一个实例工厂,创建业务层实现类
* 此工厂创建对象,必须现有工厂实例对象,再调用方法
*/
public class InstanceFactory {
public IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是:
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法createAccountService()来获取我们真正需要的AccountServiceImpl对象
factory-bean 属性:用于指定实例工厂 bean 的 id。
factory-method 属性:用于指定实例工厂中创建对象的方法。
-->
<!--所以需要书写两个bean -->
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>
第三种方式:spring 管理静态工厂-使用静态工厂的方法创建对象(模拟一个工厂类,这个类可能是存在于jar中,我们无法通过修改源码的方式来提供默认构造函数)
/**
- 模拟一个静态工厂,创建业务层实现类
*/
public class StaticFactory {
public static IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
bean 的作用范围–是对对象而言的
scope:指定对象的作用范围。
* singleton :默认值,单例的.
* prototype :多例的.
* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
bean 的生命周期
单例对象:scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期:
对象出生:当应用加载,创建容器时,对象就被创建了。
对象活着:只要容器在,对象一直活着。
对象死亡:当应用卸载,销毁容器时,对象就被销毁了。
多例对象:scope=“prototype”
每次访问对象时,都会重新创建对象实例。
生命周期:
对象出生:当使用对象时,创建新的对象实例。
对象活着:只要对象在使用中,就一直活着。
对象死亡:当对象长时间不用时,被 java 的垃圾回收器回收了。
2.3.spring 的依赖注入数据,它是 spring 框架核心 ioc 的具体实现
IOC的作用:降低程序间的耦合/依赖关系,但依赖关系的管理,都交给spring来维护,在当前类需要用到其他类的对象,由spring为我们提供,我们只需要在配置文件中说明。那这种业务层和持久层的依赖关系,在使用 spring 之后,就让 spring 来维护了。简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取。
依赖关系的维护:
就称之为依赖注入。
依赖注入:
能注入的数据:有三类
基本类型和String
其他bean类型(在配置文件中或者注解配置过的bean)
复杂类型/集合类型
注入的方式:有三种
第一种:使用构造函数提供
第二种:使用set方法提供
第三种:使用注解提供(明天的内容)
构造函数注入 —不推荐
1.创建一个类,里面写上构造函数
package inject.service.impl;
import inject.service.IAccountService;
import java.util.Date;
/**
* 账户的业务层实现类,用于构造函数注入,这里假设AccountServiceImpl类的字段是不经常变化的,
* 因为要在xml文件中输入value值,频繁修改是不想要的,但这样写的目的主要是演示注入基本类型,
* String和其他bean类型
*/
public class AccountServiceImpl implements IAccountService {
private String name;//字符串类型
private Integer age;//基本类型
private Date birthday;//Bean类型
public AccountServiceImpl(String name,Integer age,Date birthday){
this.name=name;
this.age=age;
this.birthday=birthday;
}
public void saveAccount(){
System.out.println("service中的saveAccount方法执行了..."+name+","+age+","+birthday);
}
}
2.配置文件
优势: 在获取bean对象时,注入数据是必须的操作,否则对象无法创建成功。
弊端 改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供。
<!--1.构造函数注入
使用的标签:constructor-arg
标签出现的位置:bean标签的内部
标签中的属性
type:用于指定要注入的数据的数据类型,该数据类型也是构造函数中某个或某些参数的类型
index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
name:用于指定给构造函数中指定名称的参数赋值 常用的
=============以上三个都是用于指定给构造函数中哪个参数赋值===============================
value:用于提供基本类型和String类型的数据
ref:用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象(比如自己配置的日期对象) -->
<bean id="accountService" class="inject.service.impl.AccountServiceImpl">
<constructor-arg name="name" value="研究生"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>
3.测试类
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
/**
* 获取spring的ioc核心容器,并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//采用ApplicationContext创建对象,也是演示ApplicationContext创建对象的过程
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("beanInject4.xml");
// ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");
//2.1 构造函数注入,根据id获取Bean对象
IAccountService is=(IAccountService)ac.getBean("accountService");//把object对象,强转成IAccountService对象
is.saveAccount();
}
}
set方法注入
1.创建类,用于测试set方法,这里不需要写get方法
package inject.service.impl;
import inject.service.IAccountService;
import java.util.Date;
/**
* 账户的业务层实现类,用于set方法注入,不需要写get
*/
public class AccountServiceImpl2 implements IAccountService {
private String name;//字符串类型
private Integer age;//基本类型
private Date birthday;//Bean类型
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public void saveAccount(){
System.out.println("service中的saveAccount方法执行了..."+name+","+age+","+birthday);
}
}
2.配置文件
<!-- 2.set方法注入 更常用的方式
涉及的标签:property
出现的位置:bean标签的内部
标签的属性
name:用于指定注入时所调用的set方法名称
value:用于提供基本类型和String类型的数据
ref:用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势:
创建对象时没有明确的限制,可以直接使用默认构造函数
弊端:
如果有某个成员必须有值,则获取对象是有可能set方法没有执行。
-->
<bean id="accountService2" class="inject.service.impl.AccountServiceImpl2">
<property name="name" value="兰亭序"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>
3.测试类 --模拟一个表现层,用于调用业务层
public class Client {
/**
* 获取spring的ioc核心容器,并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//采用ApplicationContext创建对象,也是演示ApplicationContext创建对象的过程
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("beanInject4.xml");
// ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");
//2.2 set注入
IAccountService is2=(IAccountService)ac.getBean("accountService2");//把object对象,强转成IAccountService对象
is2.saveAccount();
复杂数据类型的set方法注入
1.创建类 --同理类的get方法也可以不写
package inject.service.impl;
import inject.service.IAccountService;
import java.util.*;
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl3 implements IAccountService {
private String[] str;
private List<String> list;
private Set<String> set;
private Map<String,String> map;
private Properties prop;
public String[] getStr() {
return str;
}
public void setStr(String[] str) {
this.str = str;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public Properties getProp() {
return prop;
}
public void setProp(Properties prop) {
this.prop = prop;
}
public void saveAccount(){
System.out.println(Arrays.toString(str));
System.out.println(list);
System.out.println(set);
System.out.println(map);
System.out.println(prop);
}
}
2.配置文件
<!-- 复杂类型的注入/集合类型的注入
用于给List结构集合注入的标签:
list array set
用于个Map结构集合注入的标签:
map props
结构相同,标签可以互换
-->
<bean id="accountService3" class="inject.service.impl.AccountServiceImpl3">
<property name="str">
<array>
<value>研究生</value>
<value>兰亭序</value>
<value>潘九弟</value>
</array>
</property>
<property name="list">
<list>
<value>研究生</value>
<value>兰亭序</value>
<value>潘九弟</value>
</list>
</property>
<property name="set">
<set>
<value>研究生</value>
<value>兰亭序</value>
<value>潘九弟</value>
</set>
</property>
<property name="map">
<map>
<entry key="a" value="研究生"></entry>
<entry key="b" >
<value>兰亭序</value>
</entry>
<entry key="c" value="潘九弟"></entry>
</map>
</property>
<property name="prop">
<props>
<prop key="a">研究生</prop>
<prop key="b">兰亭序</prop>
<prop key="c">潘九弟</prop>
</props>
</property>
</bean>
3.测试类跟上面的一样,只是全限定行名变了
3.基于注解的Ioc配置
曾经xml的配置:
* <bean id="accountServive" class="ioc_xml.service.impl.AccountServiceImpl"></bean>
*
*用于创建对象的注解
* * 他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
* * Component:
* * 作用:用于把当前类对象存入spring容器中
* * 属性:
* * value:用于指定bean的id(比如:设置了@Component(value = "accountServiceImpl"),那么在ac.getBean()创建bean对象时,可以根据我们设置的id名来获取,ac.getBean("accountServiceImpl"))。
* 当我们不写时,它的默认值是当前类名,且首字母改小写。
* *
* Controller:一般用在表现层
* * Service:一般用在业务层
* * Repository:一般用在持久层
* * 以上三个注解他们的作用和属性与Component是一模一样。
* * 他们三个是spring框架为我们提供明确的三层框架使用的注解,使我们的三层对象更加清晰
*
* 用于注入数据的注解
* * 他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
* * Autowired:
* * 作用:自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配,就可以注入成功
* * 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配,则报错。
* * 如果Ioc容器中有多个类型匹配时:
* * 出现位置:
* * 可以是变量上,也可以是方法上
* * 细节:
* * 在使用注解注入时,set方法就不是必须的了。
* * Qualifier:
* * 作用:在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以(见ioc_annotationcaseWithoutXml的JdbcConfiguration)
* * 属性:
* * value:用于指定注入bean的id。
* * Resource
* * 作用:直接按照bean的id注入。它可以独立使用
* * 属性:
* * name:用于指定bean的id。
* * 以上三个注入都只能注入其他bean类型的数据,而基本类型和String类型无法使用上述注解实现。
* * 另外,集合类型的注入只能通过XML来实现。
* *
* * Value
* * 作用:用于注入基本类型和String类型的数据
* * 属性:
* * value:用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式)
* * SpEL的写法:${
表达式}
* *用于改变作用范围的注解
* * 他们的作用就和在bean标签中使用scope属性实现的功能是一样的
* * Scope
* * 作用:用于指定bean的作用范围
* * 属性:
* * value:指定范围的取值。常用取值:singleton prototype
* *
* * 和生命周期相关的注解 了解
* * 他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的
* * PreDestroy
* * 作用:用于指定销毁方法
* * PostConstruct
* * 作用:用于指定初始化方法
这里有一部很重要的操作: 告知spring在创建容器时要扫描的包,当扫描这个包时,就会扫描包及其子包所有类的注解,配置所需要
的标签不在beans的约束中,而是一个名称为context名称空间和约束中。所以xml配置需要多加一个context约束以实现注解配置
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--告知spring在创建容器时要扫描的包,当扫描这个包时,就会扫描包及其子包所有类的注解,配置所需要
的标签不在beans的约束中,而是一个名称为context名称空间和约束中-->
<context:component-scan base-package="ioc_annotation5"/>
</beans>
3.1 通过对象注解获取对象 Component,Controller, Service, Repository
1.创建service类,记得加注解@Component,或@Service
package ioc_annotation5_1.service.impl;
import ioc_annotation5_1.dao.IAccountDao;
import ioc_annotation5_1.service.IAccountService;
import org.springframework.stereotype.Component;
@Component //等同与下面的Service注解
//@Component(value = "accountServiceImpl") //只有value一个属性,也是可以不写的
public class AccountServiceImpl implements IAccountService {
private IAccountDao accountDao;
public AccountServiceImpl(){
System.out.println("AccountServiceImpl对象被创建。。。");
}
public void saveAccount(){
accountDao.saveAccount();
}
}
2.创建持久层类
package ioc_annotation5_1.dao.impl;
import ioc_annotation5_1.dao.IAccountDao;
/**
* 账户的持久层实现类
*/
public class AccountDaoImpl implements IAccountDao {
public void saveAccount(){
System.out.println("AccountDaoImpl1保存了账户");
}
}
3.配置文件
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--告知spring在创建容器时要扫描的包,当扫描这个包时,就会扫描包及其子包所有类的注解,配置所需要
的标签不在beans的约束中,而是一个名称为context名称空间和约束中-->
<context:component-scan base-package="ioc_annotation5_1"/>
</beans>
4.创建测试类类
package ioc_annotation5_1.ui;
import ioc_annotation5_1.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
/**
* 获取spring的ioc核心容器,并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("beanAnnotation.xml");
//2.根据id获取Bean对象
IAccountService is1=(IAccountService)ac.getBean("accountServiceImpl");//把object对象,强转成IAccountService对象
System.out.println(is1);
}
}
同理AccountDaoImpl对象也是同样方式获取
只需要在AccountDaoImpl加上@Repository注解即可
package ioc_annotation5_1.dao.impl;
import ioc_annotation5_1.dao.IAccountDao;
import org.springframework.stereotype.Repository;
/**
* 账户的持久层实现类
*/
@Repository
public class AccountDaoImpl implements IAccountDao {
public void saveAccount(){
System.out.println("AccountDaoImpl1保存了账户");
}
}
测试类多添加一个获取accountDaoImpl对象的方法
public class Client {
/**
* 获取spring的ioc核心容器,并根据id获取对象
* @param args
*/
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("beanAnnotation.xml");
//2.根据id获取Bean对象
IAccountService is1=(IAccountService)ac.getBean("accountServiceImpl");//把object对象,强转成IAccountService对象
System.out.println(is1);
IAccountDao ad1 = (IAccountDao)ac.getBean("accountDaoImpl");
System.out.println(ad1);
}
}
3.2 通过数据注解获取获取 Autowired,Qualifier,Resource,Value,Xml
3.1章节讲的是是对象注解,就是把对象通过注解的方式加载进spring容器,而如何让业务层对象调用持久层对象呢,就需要数据的注解。
Autowired注解
只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配,就可以注入成功,如果ioc容器