一、Spring 简介
1、什么是 Spring
Spring 是一个用于简化企业级 Java 开发的利用框架
Spring 以 IoC（管制反转）和 AOP（面向切面编程）为外围，提供了体现层的 SpringMVC 反对，也提供了业务层的申明式事务反对，以及提供了长久层的 JdbcTemplate 反对。Spring 除了本身所提供的性能外，还能够作为一个粘合剂，用于整合优良的第三方技术框架。SSH（spring 整合 Struts2、spring 整合 Hibernate）SSH（spring 整合 SpringMVC、spring 整合 Mybatis）2、Spring 的劣势
1）不便解耦，简化开发
2）提供了 AOP、申明式事务反对（前面阶段解说）3）对 JavaEE 进行了封装，升高开发难度。。。二、Spring 的 IoC
1、耦合、解耦的概念
耦合: 是指对象和对象之间产生的依赖关系, 依赖关系越高, 耦合性越高, 依赖关系越低, 耦合性越低。在开发我的项目时，尽量不要让对象之间的依赖关系太高。解耦: 升高对象之间耦合性的过程叫做解耦(解耦只是升高耦合性, 但不能彻底消除)
Class AnimalTest{Animal ani = spring 容器对象.getBean("animal")
//Animal ani = new Cat();}
interface Animal{}
class Cat implements Animal{}
------------------------------------------------
beans.xml
animal com.tedu.Cat2、Spring IoC 概念
IoC（Inverse Of Control）：管制反转，是指将对象的创立交给框架负责
在 spring 框架之前，当须要对象，咱们负责管制对象的创立（new 的模式），以及对象的销毁
但因为 new 对象会造成对象之间的依赖关系晋升(即耦合度晋升)
因而能够将对象的创立交给 spring 负责，将创建对象的权力交给框架，这里咱们称之为 "管制反转"
3、Spring IoC 入门
1）创立 Maven 的 java 工程：CGB-SPRING-01
2）在 pom.xml 文件中导入 junit、spring 的依赖包
3）提供 com.tedu.pojo.User 类(将 User 类的实例交给 spring 框架创立)
4）在 src/main/resources 下提供 spring 的配置文件 --beans.xml, 并增加如下配置
<!-- 将 User 作为 bean 拆卸到 spring 容器中(将 User 类的实例交给 spring 容器创立)
id 属性: 定义一个编号, 未来通过这个编号能够获取以后类的实例（id 必须是惟一的）id 值通常是以后类的类名(但首字母小写), 或者以后类父接口的接口名(首字母小写)
class 属性: 指定以后类的全类名(spring 框架会通过反射 + 全类名创立该类的实例) -->
<bean id="user" class="com.tedu.pojo.User">
5）提供测试类，测试 spring 的 IoC
public class SpringTest {
// 获取 spring 的容器对象
ClassPathXmlApplicationContext ac =
new ClassPathXmlApplicationContext("beans.xml");
/* 1、测试 spring 的 IoC */
@Test
public void testIoC(){// 从 spring 容器中获取 User 类的实例(对象)
User user = (User)ac.getBean("user"); // 依据 id 获取 bean
}
}
三、Spring 的单实例和多实例
/*
* 单例: 默认 spring 容器中所有的 bean 对象都是单例的(即每个类只创立一个对象)
* 长处: 无论获取一个 bean 多少次, 返回都是同一个实例(因为只创立了一个实例)
* 能够节俭内存空间, 缩小资源节约。* 毛病: 可能会引发线程平安问题（如果这个惟一对象上有共享数据, 并且多个线程会同时
* 操作这个共享数据）* 单例的 bean 是在 beans.xml 文件一被读取就会创立实例, 而且会存到 bean 池中
*
* 多例: 如果在 bean 标签上设置 scope="prototype", 以后 bean 对象就是多例的
* <bean id="user" scope="prototype" class="com.tedu.pojo.User">
* 每次获取以后类的实例, spring 容器都会创立该类的新的实例
* 长处: 不会引发线程平安问题(因为每个线程持有的实例是不同的)
* 毛病: 因为每次获取都会创立新的实例, 会占用服务器的内存空间, 浪费资源
* 多例的 bean 是每次获取时才会创立实例, 而且创立的实例不会存到 bean 池中
*
* 总结: 从应用频次上, 如果一个对象应用的频率特地高, 倡议应用单例
* 反过来说, 如果一个对象应用频率特地低, 倡议应用多例。*/
@Test
public void testScope() {// 获取 UserInfo 类的实例(多例)
UserInfo info1 = (UserInfo)ac.getBean("userInfo");
UserInfo info2 = (UserInfo)ac.getBean("userInfo");
System.out.println(info1 == info2); //false, 地址不相等, 阐明不是同一个对象
// 获取 User 类的实例(单例)
User u1 = (User)ac.getBean("user");
User u2 = (User)ac.getBean("user");
System.out.println(u1 == u2); //true, 因为是同一个对象, 所以地址相等
}
四、Spring 的 DI
/*
* 测试 spring 的 DI（依赖注入）* 依赖注入：在创建对象的同时或者之后，为对象的属性赋值
* 1）set 办法注入：在创建对象之后，框架在底层调用对象的 setXxx 办法为 xxx 属性赋值
* 例如: 调用 setName 办法给 name 属性赋值
* 2）构造方法注入：底层是在创建对象的同时, 通过构造方法给对象的属性赋值
*/
@Test
public void testDI() {
// 获取 User 类的实例
User user = (User)ac.getBean("user");
System.out.println(user);
}
========================================================
<!-- 应用 set 办法为 User 对象的 name、age、info 变量赋值
须要留神的是: name 属性指定的值, 在以后类中得有对应的 set 办法 -->
<bean id="user" class="com.tedu.pojo.User">
<property name="name" value="韩少云" />
<property name="age" value="30" />
<property name="info" ref="userInfo"/>
</bean>
========================================================
<!-- 应用构造方法为 User 对象的 name、age、info 属性赋值
其中 name 属性的值 要和构造方法上形参的名字保持一致
-->
<bean id="user" class="com.tedu.pojo.User">
<constructor-arg name="name" value="马云"/>
<constructor-arg name="age" value="38"/>
<constructor-arg name="info" ref="userInfo"/>
</bean>
========================================================五、Spring 的全注解开发
1、spring 全注解开发入门
1）创立 Maven 的 java 工程：CGB-SPRING-02
2）在 pom.xml 文件中导入 junit、spring 的依赖包
3）提供 com.tedu.pojo.User 类(将 User 类的实例交给 spring 框架创立)
4）提供 com.tedu.AppConfig 类，作为 Java 配置类
========================================================
/* @Configuration: 告诉 spring 框架这是一个 Java 配置类, spring 框架通过
* 这个类中的配置, 生成 spring 容器对象。AppConfig 类 == beans.xml 文件
*/
@Configuration
public class AppConfig {/* @Bean(name="user"): 将以后办法的返回值作为 bean 拆卸到 spring 容器中
* 其中 name 指定的值就是 bean 的 id 值(即 bean 的名称), 相当于 <bean> 标签
* 如果不增加括号及其中的 name 属性, bean 的 id 值就是办法名 */
@Bean(name="user")
public User getUser() {User user = new User();
user.setName("赵云");
user.setAge(28);
return user;
}
}
========================================================
5）提供测试类，测试 spring 的全注解开发
public class SpringTest {
// 获取 spring 的容器对象
AnnotationConfigApplicationContext ac =
new AnnotationConfigApplicationContext(AppConfig.class);
/* 1、测试 spring 的全注解开发 */
@Test
public void testIoC01() {
// 从 spring 容器中获取 User 类的实例
User u1 = (User)ac.getBean("user");
System.out.println(u1);
}
}
2、通过扫描拆卸 Bean
1）将下面 AppConfig 中 @Bean 注解及标记的 getUser 办法 正文或者间接删除
2）在 AppConfig 类上增加 @ComponentScan 注解
/* @Configuration: 告诉 spring 框架这是一个 Java 配置类, spring 框架通过
* 这个类中的配置, 生成 spring 容器对象。AppConfig 类 == beans.xml 文件
* @ComponentScan: 用于配置以何种策略扫描拆卸 bean, 如果前面什么都不加
* 默认扫描以后类所在的包 (com.tedu) 及其子包(com.tedu.*)
* 如果扫描到包中的类上有 @Component 注解, 就会将这个类作为 bean 进行拆卸
*/
@Configuration
@ComponentScan
public class AppConfig {/* ... */}
3）在 User 类上增加 @Component("user") 注解
@Component("user")
public class User {...}
4）再执行 SpringTest 类中 testIoC01 办法进行测试
@ComponentScan: 配置以何种形式扫描拆卸 bean, 默认扫描以后类所在的包及其子包
比方, 以后类是 com.tedu.AppConfig, 所在的包就是 com.tedu
默认扫描的包就是 com.tedu 包以及以 com.tedu 结尾的所有子包
@ComponentScan(basePackages = "com.tedu.dao")
basePackages 指定扫描哪个包, 下面指定了只扫描 com.tedu.dao 包
@ComponentScan(basePackages = { "com.tedu.dao", "com.tedu.service"} )
basePackages 同时能够指定扫描多个包, 将多个包放在一个数组中即可,
下面指定了扫描 com.tedu.dao 包 和扫描 com.tedu.service 包
3、@AutoWired 主动拆卸(依赖注入)
如果是给一个字符串类型的变量或者数值类型的变量赋值, 能够间接通过 @Value 注解给对象的属性赋值。1)批改 User 类, 在 User 类中增加一个 Animal 类型的 animal 属性, 并提供对应的 get 和 set 办法
2)重写 User 类中的 toString 办法
3)增加一个 com.tedu.pojo.Animal 接口, 并未 Animal 接口提供一个实现类 --com.tedu.pojo.Dog
4)通过 @AutoWired 注解为 User 对象的 animal 属性赋值, 赋的值是一个 Animal 类型的对象
@Component("dog") // 将 Dog 类作为 bean 拆卸到 spring 容器中（spring 容器中是蕴含 Dog 对象的）public class Dog implements Animal
@Autowired
private Animal animal;
@Autowired 注解的作用：1）@AutoWired 注解是咱们应用十分多的注解之一，它能够将定义好的 bean 对象（比方 Dog 对象）作为值 赋值给其它对象的属性。这个过程是主动实现的，咱们称之为主动拆卸（依赖注入）2）@AutoWired 注解默认优先依照（Animal）类型到 spring 容器中进行查找 bean，如果找到一个则间接将这个 bean 对象作为值赋值给 animal 属性。如果找不到，则抛出异样！3）如果该类型（Animal）的 bean 在 spring 容器中有多个，此时还会依据变量名 / 属性名去匹配，如果变量名 / 属性名 和 bean 的 id 值雷同，就能够主动拆卸。如果都不雷同，也会抛出异样。4）如果该类型（Animal）的 bean 在 spring 容器中有多个，能够通过 @Qualifier 显式的为属性指定要注入哪一个名称的 bean
4、@Scope 指定 bean 的作用范畴
@Scope("prototype")
public class User{...}
如果不指定 scope 属性或者 @Scope 注解, 在 spring 容器中所有的 bean 都是单实例的(spring 容器为所有的类只创立一个实例。)
如果指定 scope="prototype" 或者 @Scope("prototype"), 能够指定以后 bean 为多实例, 即每次通过 spring 容器获取以后类的实例, 都会创立新的 bean 对象并返回!