一、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();
}结果：
