一、Spring概述
1.Spring是什么
Spring是分层的Java SE/EE应用full-stack轻量级开源框架,以IOC(Inversion Of Control:控制反转)和AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE企业应用开源框架
2.Spring体系结构
二、程序的耦合及解耦
1.耦合连接JDBC
public static void main(String[] args) throws SQLException {
//1.注册驱动
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//2.获取连接
Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/spring_study","root","wh456159");
//3.获取操作数据库的预处理
PreparedStatement pstm=conn.prepareStatement("select * from account");
//4.执行SQL,得到结果集
ResultSet rs=pstm.executeQuery();
//5.遍历结果集
while (rs.next()){
System.out.println(rs.getString("name") );
}
//6.释放资源
rs.close();
pstm.close();
conn.close();
}
* 程序的耦合
* 耦合:程序间的依赖关系
* 包括:
* 类之间的依赖
* 方法间的依赖
2.解耦
* 解耦:降低程序间的依赖关系
* 实际开发中:做到编译期不依赖,运行时才依赖。
* 解耦的思路:
* 第一步:使用反射来创建对象,而避免使用new关键字
//1.注册驱动
// DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
注:反射中,欲获取一个类或者调用某个类的方法,首先要获取到该类的 Class 对象。
获取 Class 对象三种方法:①使用 Class.forName 静态方法 ②使用 .class 方法 ③使用类对象的 getClass() 方法
但上述使用Class.forName("com.mysql.jdbc.Driver") 如果之后更换数据库例如使用oracle时,代码就不成立。
* 第二步:通过读取配置文件来获取要创建的对象全限定类名
* 配置文件可以是xml也可以是properties
此处使用properties:(在resouces目录下创建.properties,然后分别指定业务层acountService和持久层acountDao的实现类的全限定类名)

accountService=com.wuhao.service.implement.AccountServiceImpl
accountDao=com.wuhao.dao.implement.AccountDaoImpl
/**
* 一个创建Bean对象的工厂
*
* Bean:在计算机英语中,有可重用组件的含义
* JavaBean: 用Java语言编写的可重用组件
* javabean > 实体类
*
* 它就是创建我们的service和dao对象的
*
* 第一个:需要一个配置文件来配置我们的service和dao
* 配置的内容:唯一标识=全限定类名(key=value)
* 第二个:通过读取配置文件中配置的内容,反射创建对象
*
* 配置文件可以是xml也可以是properties
*/
public class BeanFactory {
//定义一个Properties对象
private static Properties properties;
//定义一个Map,用于存放我们要创建的对象。 称之为容器
private static Map<String,Object> beans;
//使用静态代码块为Properties对象赋值
static {
try {
//实例化对象
properties=new Properties();
//获取properties文件的流对象
// InputStream inputStream=new FileInputStream(""); 使用这种方法增加了耦合性
InputStream inputStream=BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"); //使用类加载器
properties.load(inputStream);
//实例化容器
beans=new HashMap<String, Object>();
//取出配置文件中所有的key
Enumeration keys=properties.keys();
//遍历枚举
while (keys.hasMoreElements()) {
//取出每个key
String key=keys.nextElement().toString();
//根据key获取value
String beanPath=properties.getProperty(key);
//反射创建对象
Object value=Class.forName(beanPath).newInstance();
//把Key和Value存入容器中
beans.put(key, value);
}
} catch (IOException e) {
throw new ExceptionInInitializerError("初始化properties失败!");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 根据bean的名称获取对象
* @param beanName
* @return
*/
public static Object getBean(String beanName){ //实现了单例模式
return beans.get(beanName);
}
/**
* 根据Bean的名称获取bean对象
* @param beanName
* @return
*/
/* public static Object getBean(String beanName){ //多例模式
Object bean=null;
try {
String beanPath=properties.getProperty(beanName);
bean=Class.forName(beanPath).newInstance(); //实例化 每次都会调用默认构造函数创建对象 若长时间不用会被java垃圾回收机制销毁
} catch (Exception e) {
e.printStackTrace();
}
return bean;
}*/
}
三、IOC概念和Spring中的IOC
1.IOC
通过代码解释IOC(Inversion Of Control:控制反转):
private IAccountDao accountDao=new AccountDaoImpl();
用关键字new创建对象,就像从APP寻找资源一样,会存在必然联系。这时候对于应用的独立变得很难
private IAccountDao accountDao= (IAccountDao) BeanFactory.getBean("accountDao");
这种方式下,APP已经断开了与资源的联系。APP找工厂索要资源,由工厂负责与资源取的联系,并把想要的资源转到APP中。
这种被动接收的方式获取对象的思想就是控制反转,它是spring框架的核心之一。
控制反转(Inversion of Control)把创建对象的权利交给框架,是框架的重要特征,并非面向对象编程的专用术语。它包括依赖注入(Dependency Injection,DI)和依赖查找(Dependency Lookup)。
IOC作用:消减计算机程序的耦合(解除我们代码中的依赖关系)。
2.Spring中的IOC
* 获取spring的IOC核心容器,并根据id获取对象
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");//bean.xml为配置文件
//2.根据id获取Bean对象 两种方式(强转或指定接口)
IAccountService as=(IAccountService)ac.getBean("accountService");
IAccountDao adao=ac.getBean("accountDao",IAccountDao.class);
*在Spring中的配置文件
<!--Spring对bean的管理细节
1.创建Bean的三种方式
2.Bean对象的作用范围
3.Bean对象的生命周期
-->
<!--创建Bean的三种方式-->
<!--第一种方式:使用默认构造函数创建
在Spring的配置文件中使用bean标签,配以id和class属性之后,且没有其他属性和标签时
采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数,则对象无法创建
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl"></bean>
-->
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
/**
* 解耦后
*/
public AccountServiceImpl(){
System.out.println("对象已创建");
} //默认构造函数
@Override
public void saveAccount() {
System.out.println("service中的saveAccount方法执行了。。。");
}
}
<!--第二种方式:使用普通工厂中的方法创建对象(使用某个类中的方法创建对象,并存入spring容器)
<bean id="instanceFactory" class="com.wuhao.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
-->
/**
* 模拟一个工厂类(该类可能是存在于jar包中,我们无法通过修改源码的方式来提供默认构造函数)
*/
public class InstanceFactory {
public IAccountService getAccountService() {
System.out.println("InstanceFactory被调用");
return new AccountServiceImpl();
}
}
<!--第三种方式:使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象,并存入spring容器)
<bean id="accountService" class="com.wuhao.factory.StaticFactory" factory-method="getAccountService" ></bean>
-->
public class StaticFactory {
public static IAccountService getAccountService() {
System.out.println("StaticFactory被调用");
return new AccountServiceImpl();
}
}
<!--bean的作用范围调整
bean标签的scope属性:
作用:用于指定bean的作用范围
取值:
singleton:单例的(默认值)
prototype:多例的
request:作用于web应用的请求范围
session:作用于web应用的会话范围
global-session:作用于集群环境的会话范围(全局会话范围),当不是集群环境时,它就是session
-->
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl"></bean>
public static void main(String[] args) {
//1.获取核心容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取Bean对象
IAccountService as1=(IAccountService)ac.getBean("accountService");
IAccountService as2=(IAccountService)ac.getBean("accountService");
System.out.println(as1==as2);
}
结果:
改变配置文件,加入scope属性:
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl" scope="prototype"></bean>
结果:
<!--bean对象的生命周期
单例对象
出生:当容器创建时对象出生
活着:只要容器还在,对象一直活着
死亡:容器摧毁,对象消亡
总结:单例对象的生命周期和容器相同
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl"
scope="singleton" init-method="init" destroy-method="destroy"></bean>
public static void main(String[] args) {
//1.获取核心容器对象
// ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取Bean对象
IAccountService as=(IAccountService)ac.getBean("accountService");
as.saveAccount();
//手动关闭容器
ac.close();
}
结果:
多例对象
出生:当使用对象时spring框架为我们创建
活着:对象在使用过程中一直活着。
死亡:当对象长时间不用,且没有别的对象引用是,由Java的垃圾回收器回收
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl"
scope="prototype" init-method="init" destroy-method="destroy"></bean>
结果:
四、依赖注入(Dependency Injection)
<!--Spring中的依赖注入
依赖注入(dependency Injection)
IOC作用:降低程序间的耦合(依赖关系)
依赖关系的管理:
以后都交给spring来维护
在当前类需要用到其他类的对象,由spring为我们提供,我们只需要在配置文件中说明
依赖关系的维护:
就称之为依赖注入。
依赖注入:
能注入的数据:有三类
基本类型和String
其他bean类型(在配置文件中或者注解配置过的bean)
复杂类型/集合类型
注入的方式:有三种
第一种:使用构造函数提供
第二种:使用set方法提供
第三种:使用注解提供
-->
<!--构造函数注入:
使用的标签: constructor-arg
标签出现的位置: bean标签的内部
标签中的属性
type:用于指定要注入的数据的数据类型,该数据类型也是构造函数中某个或某些参数的类型
index:用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
name:用于指定给构造函数中指定名称的参数赋值
=================以上三个用于指定给构造函数中哪个参数赋值====================
value:用于提供基本类型和string类型的数据
ref:用于指定其他的bean类型数据。 它指的就是在Spring的IOC核心容器中出现过的bean对象
优点: 在获取bean对象时(方法中不存在无参构造函数),注入数据是必须的操作,否则对象无法创建成功。
缺点:改变了bean对象的实例化方式,使我们在创建对象时,如果用不到这些数据,也必须提供。
-->
/**
* 账户的业务层实现类
*/
public class AccountServiceImpl implements IAccountService {
//如果是经常变化的数据,并不适用于注入的方式
private String name;
private Integer age;
private Date birthday;
public AccountServiceImpl(String name,Integer age,Date birthday){
this.name = name;
this.age = age;
this.birthday=birthday;
}
@Override
public void saveAccount() {
System.out.println("service中的saveAccount方法执行了。。。");
System.out.println(name+age+birthday);
}
}
<bean id="accountService" class="com.wuhao.service.implement.AccountServiceImpl"
scope="prototype">
<constructor-arg name="name" value="John"></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>
<!--set方法注入 (常用)
涉及的标签:property
出现的位置:bean标签的内部
标签中的属性
name:用于指定注入时所调用的set方法名称
value:用于提供基本类型和string类型的数据
ref:用于指定其他的bean类型数据。 它指的就是在Spring的IOC核心容器中出现过的bean对象
优点:创建对象时没有明确的限制,可以直接使用默认构造函数。
缺点:如果有某个成员必须有值,则获取对象是有可能set方法没有执行
-->
public class AccountServiceImpl02 implements IAccountService {
//如果是经常变化的数据,并不适用于注入的方式
private String name;
private Integer age;
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setUserAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println("service中的saveAccount方法执行了。。。");
System.out.println(name+age+birthday);
}
}
<bean id="accountService2" class="com.wuhao.service.implement.AccountServiceImpl02">
<property name="name" value="Susan"></property>
<property name="userAge" value="18"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>
注:userAge,这是因为name:用于指定注入时所调用的set方法名称,在AccountServiceImp02实现类里面使用setUserAge()方法设置age的值。
<!--复杂类型的注入/集合类型注入
用于给List结构集合注入的标签:
list array set
用于给Map结构集合注入的标签:
map props
结构相同,标签可以互换
-->
public class AccountServiceImpl03 implements IAccountService {
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;
private Properties myProperties;
@Override
public void saveAccount() {
System.out.println(Arrays.toString(myStrs));
System.out.println(myList);
System.out.println(mySet);
System.out.println(myMap);
System.out.println(myProperties);
}
public String[] getMyStrs() {
return myStrs;
}
public void setMyStrs(String[] myStrs) {
this.myStrs = myStrs;
}
public List<String> getMyList() {
return myList;
}
public void setMyList(List<String> myList) {
this.myList = myList;
}
public Set<String> getMySet() {
return mySet;
}
public void setMySet(Set<String> mySet) {
this.mySet = mySet;
}
public Map<String, String> getMyMap() {
return myMap;
}
public void setMyMap(Map<String, String> myMap) {
this.myMap = myMap;
}
public Properties getMyProperties() {
return myProperties;
}
public void setMyProperties(Properties myProperties) {
this.myProperties = myProperties;
}
}
<bean id="accountService3" class="com.wuhao.service.implement.AccountServiceImpl03">
<property name="myStrs">
<list>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</list>
</property>
<property name="myList">
<set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</set>
</property>
<property name="mySet">
<array>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</array>
</property>
<property name="myMap">
<map>
<entry key="testA" value="AAA"></entry>
<entry key="testB" value="BBB"></entry>
<entry key="testC" value="CCC"></entry>
</map>
</property>
<property name="myProperties">
<props>
<prop key="testA">AAA</prop>
</props>
</property>
</bean>
public static void main(String[] args) {
//1.获取核心容器对象
// ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取Bean对象
// IAccountService as=(IAccountService)ac.getBean("accountServi ce");
// as.saveAccount();
// IAccountService as=(IAccountService)ac.getBean("accountService2");
// as.saveAccount();
IAccountService as=(IAccountService)ac.getBean("accountService3");
as.saveAccount();
}
结果: