Spring-IOC
Spring
Spring简介
1.解决企业应用开发的复杂性，可以解决Java SE的问题
2.2002年，推出Spring的雏形
3.2004年，Spring正式发布1.0版本（据说Spring的框架是以Interface21的框架进行重新设计，并不断填充内容从而形成）
4.Spring理念：使得现有的技术更易使用。整合现有的技术框架（Spring提供了许多的应用程序架构，包括通讯、数据、事务持久性和网络，还包括基于Spring MVC Web框架等）
5.SSM：Spring SpringMVC Mybatis
-Spring：一个容器会集成很多东西
-Mybatis：半自动化，相对于Hibernate来说可定制性更强，更易于使用。
6.内容准备：
- 官网下载jar包：https://repo.spring.io/release/org/springframework/spring/
-github下载：https://github.com/spring-projects/spring-framework - 引入Maven依赖：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.6</version>
</dependency>
Spring的优点：
- Spring是一个开源的免费的框架（容器）
- Spring是一个轻量级的，非入侵式的框架（轻量级：很小巧，下载jar包或者引入依赖就可以使用；非入侵：引入Spring不会对原有的代码产生影响，入侵式则相反）
- 控制反转（IOC），面向切面编程（AOP）
- 支持事务处理
- 能够整合大多数的框架
Spring的组成
扩展
现在化的java开发就是基于Spring的开发
- Spring：
一个快速开发的脚手架。
基于SpringBoot可以快速的开发单个微服务
约定大于配置（按照配置进行搭建） - Spring Clound
基于Spring Clound基于Spring Boot实现的
学习Spring Boot的前提：掌握Spring和SpringMVC
弊端
配置十分繁琐（违背了早期易于使用的理念）
IOC理论推导
1.UserDao接口
package com.test.dao;
public interface UserDao {
void getUser();
}
2.UserDaoImpl实现类
package com.test.dao;
public class UserDaoImpl implements UserDao{
public void getUser() {
System.out.println("默认获取用户的数据");
}
}
package com.test.dao;
public class UserDaoMysqlImpl implements UserDao{
public void getUser() {
System.out.println("Mysql用户获取数据");
}
}
package com.test.dao;
public class UserDaoOracleImpl implements UserDao{
public void getUser(){
System.out.println("Oracle用户获取数据");
}
}
3.UserService接口
package com.test.Service;
public interface UserService {
void getUser();
}
4.UserService实现类
package com.test.Service;
import com.test.dao.UserDao;
import com.test.dao.UserDaoImpl;
import com.test.dao.UserDaoMysqlImpl;
public class UserServiceImpl implements UserService{
// 重新添加一个UserDaoImpl的实现类实现UserDao的接口，这里的实现参数需要改变，或者UserDao中新添加一个getUsermysql这个方法
// private UserDao userdao = new UserDaoImpl();
private UserDao userdao;
/*
* 在以前的业务中，每增加一个Dao层的实现类在后面进行调用的时候都需要修改代码，这使得维护代码的成本极高
* 程序主动创建对象
* */
// 在增加了set方法之后，使用set注入实现，对象的接收，由此程序变成了被动的接受对象，程序不在占据主动性
// **控制反转的思想：由程序主动创建对象到被动的接收对象（降低耦合性）（依赖注入是实现控制反转的一种方法）
Spring中实现控制反转的是IOC容器，其实现方法是依赖注入**
public void setUserdao(UserDao userdao){
this.userdao=userdao;
}
public void getUser() {
userdao.getUser();
}
// public void getUsermysql(){
// usermysqldao.getUser();
// }
}
IOC创建对象的方式
1.默认使用无参构造
所有的bean一注册就被创建了，并且只有一个对象，（被bean中的class=""引用的类，每次被引用无参构造就被创建）
2.如果使用有参构造有几种创建对象的机会。
（1）下标赋值
<!--有参构造，按照下标注入-->
<bean id="user2" class="com.test.entity.User">
<constructor-arg index="0" value="按照下标注入值"/>
</bean>
(2)按照类型注入
<!--有参构造，按照类型注入（不建议使用）-->
<bean id="user3" class="com.test.entity.User">
<constructor-arg type="java.lang.String" value="按照类型注入值"/>
</bean>
(3)按照参数名注入（一般通过这种方式注入）
<!--有参构造，按照参数名注入-->
<bean id="user4" class="com.test.entity.User">
<constructor-arg name="name" value="按照参数名注入"/>
</bean>
<!--别名配置-->
<alias name="user4" alias="user4_alias"/>
Spring的配置
1.alias：
<!--有参构造，按照参数名注入-->
<bean id="user4" class="com.test.entity.User">
<constructor-arg name="name" value="按照参数名注入"/>
</bean>
<!--别名配置-->
<alias name="user4" alias="user4_alias"/>
2.Bean的配置：
<!--
id：bean的唯一标识符，也就是相当于对象名
class：对象所对应的全限定名：包名+类型
name：给id的参数设置别名，功能更加强大可以取多个别名，中间可以使用任意分割符隔开
-->
<bean id="userserviceimpl1" class="com.test.Service.UserServiceImpl" name="user7 user0,user99">
<property name="userdao" ref="usermysqlimpl"></property>
</bean>
3.import：一般用于团队开发，可以将多个beans.xml合为一个
<!--导入多个bean.xml，将多个人使用的bean.xml合为一个总的，相同名字的bean内容也会合并，标准命名是applicationContext.xml-->
<import resource="beans.xml"></import>
<import resource="beans1.xml"></import>
<import resource="beans2.xml"></import>
依赖注入
1.构造器注入
默认为无参构造注入
有参构造注入分为三种方式（按照下标注入、按照参数类型注入、按照参数名注入）
2.Set方式注入【重点】
-依赖注入：
·依赖：bean对象的创建依赖于容器
·注入：bean对象中的所有属性依赖于，由容器来注入！
测试类：
User.class
package com.test.entity;
import java.util.*;
public class User {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;//null
private Properties info;
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
public User(){
System.out.println("bean一注册就创建了对象");
}
public User(String name) {
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
`
Address.class
`package com.test.entity;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}``
Spring中bean.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--引用注入-->
<bean id="address" class="com.test.entity.Address">
<property name="address" value="引用类型-中国湖北省"></property>
</bean>
<bean id="user" class="com.test.entity.User">
<!--第一种普通值注入-->
<property name="name" value="String类型-我叫哈哈哈哈"></property>
<!--引用注入-->
<property name="address" ref="address"></property>
<!--数组注入-->
<property name="books">
<array>
<value>罪与罚</value>
<value>深入了解JVM</value>
<value>西游记</value>
</array>
</property>
<!--List集合注入-->
<property name="hobbys">
<list>
<value>打篮球</value>
<value>打排球</value>
<value>下棋</value>
</list>
</property>
<!--Map注入-->
<property name="card">
<map>
<entry key="1" value="图书馆卡"></entry>
<entry key="2" value="食用水卡"></entry>
<entry key="3" value="寝室门禁卡"></entry>
</map>
</property>
<!--Set集合注入-->
<property name="games">
<set>
<value>英雄联盟</value>
<value>水果忍者</value>
<value>王者荣耀</value>
</set>
</property>
<!--Null集合注入，空值跟空串不一样-->
<property name="wife">
<null></null>
</property>
<property name="info">
<props>
<prop key="username">root</prop>
<prop key="password">root</prop>
<prop key="url">mysql://1222222:3306</prop>
<prop key="driver">JDBC:mysql</prop>
</props>
</property>
</bean>
</beans>
3.拓展方式注入
C:命名空间（对应的构造器注入）
需要先引入一些东西（依赖于第三方的约束）：
`xmlns:c="http://www.springframework.org/schema/c"`
<!--使用P命名空间注入，用于无参构造-->
`<bean id="userp" class="com.test.entity.User" p:name="p命名空间"></bean>`
P:命名空间（对应的set注入的属性注入）
需要先引入一些东西（依赖于第三方的约束）：
xmlns:p="http://www.springframework.org/schema/p"`
`<!--使用P命名空间注入，用于有参构造(有参构造中设置的参数决定了这里得c命名空间能够获取到的参数public User(String name) {
this.name=name;
})，通过构造器注入-->
<bean id="userc" class="com.test.entity.User" c:name="p命名空间"></bean>
Bean的作用域
spring的bean在创建的时候默认是singleton
1.单例模式scope="singleton"
Test.class
2.原型模式scope="prototype"
Test.class
3.request、session、application、只在web开发中使用
Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找，并自动给bena装配属性
- 在Spring中的三种装配方式
1.在xml中显示的配置
2.在java中显示的配置
3.使用autowire进行自动装配
bynname和bytype
<!--<bean id="cat" class="com.test.pojo.Cat" />
<bean id="dog" class="com.test.pojo.Dog" />
<bean id="people" class="com.test.pojo.People" >
<property name="name" value="使用Bean装配"></property>
<property name="dog" ref="dog"></property>
<property name="cat" ref="cat"></property>
</bean>-->`
<!--使用byname自动装配-->
<!-- <bean id="cat" class="com.test.pojo.Cat" />-->
<!-- <bean id="dog" class="com.test.pojo.Dog" />-->
<!--byname:会自动在容器的上下文中查找和自己对象set方法后面的值对应的beanid，如果不满足则空指针异常，不能进行自动装配-->
<!-- <bean id="people" class="com.test.pojo.People" autowire="byName">-->
<!-- <property name="name" value="使用Bean装配"></property>-->
<!-- </bean>-->
<!--使用bytype自动装配-->
<!-- <bean class="com.test.pojo.Cat" />-->
<!-- <bean class="com.test.pojo.Dog" />-->
<!--bytype:在容器中的上下文，和自己对象属性类型相同的bean，类型相同甚至可以不注册名字也可以使用-->
<!-- <bean id="people" class="com.test.pojo.People" autowire="byType">-->
<!-- <property name="name" value="使用Bean装配"></property>-->
<!-- </bean>-->
使用注解实现自动装配
JDK1.5开始支持注解Spring2.5开始支持注解
要使用注解：
1.导入约束，context约束
2.配置注解的支持
<?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">
<context:annotation-config/>
Test.class
package com.test.pojo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class People{
private String name;
@Autowired(required = false) //这里的required默认是true就是不允许为空，反之设置为false表示可以为空
@Qualifier(value = "cat123")
//当beans.xml中有多个同类型bean对象时，单独使用@Autowired不能够自动装配成功，可以和@Qualifier搭配着一起使用，指定装配的对象
private Cat cat;
@Autowired
@Qualifier(value = "dog123")
private Dog dog;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", cat=" + cat +
", dog=" + dog +
'}';
}
}
@Resource注解是Java的注解也可以实现自动装配，（对beans.xml中的要求，bean注册的对象要么名字唯一要么类型唯一）
public class People{
private String name;
@Resource(name="cat123")
private Cat cat;
@Autowired
private Dog dog;
}
@Resource与@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现先找byType再找byname，而且必须要求这个对象存在！【常用】（否则会报错）
- @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下报错！【常用】
- 执行顺序不同：@Autowired通过byType的方式实现先找byType再找byname；@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！
扩展
@Nullable 字段标记这个注解，说明这个注解可以为null
使用注解开发
1.bean
2.属性如何注入
package com.test.entity;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于 <bean id="User" class="com.test.entity.User" />
//@Component 组件 没有显示的名字，名字默认就是类的小写
@Component
@Scope("sighleton") //标注为单例模式
public class User {
@Value("hhhhh") //相当于<property name="" value=""/> 在类的属性很多的时候还是使用配置文件更加的方便
private String name ;//= "哈哈哈";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
3.衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao【@Repository】
- service【@Service】
- controller【@Controller】
这四个注解都是一样的，都是代表将某个类注册到Spring中，装配Bean
4.自动装配配置 - xml文件配置，或者使用注解实现自动装配
5.作用域 - @scope("sighleton")：在类中配置注解实现单例模式原型模式的作用域的配置
- 也可以在xml文件中使
<bena scope="sighleton"/>进行配置
6.小结
xml与注解: - xml更加的万能，适用于任何场合！维护更加的简单。
- 注解不是自己类使用不了，写在各个类中，维护相对复杂！
xml与注解最佳实践： - xml用来管理bean；
- 注解只负责完成属性的注入
- 我们在使用的过程中，需要注意一个问题：xml文件中必须配置开启注解支持，使注解生效。
<!--指定扫描注解的包,这个包下的的注解就会生效-->
<context:component-scan base-package="com.test.entity"></context:component-scan>
<!--开启注解支持-->
<context:annotation-config/>
使用Java的方式配置Spring
不使用Spring的xml配置，全部使用Java（JavaConfig）进行配置
JavaConfig是Spring的一个子项目，在Spring4之后，成为了一个核心功能。
User.class
package com.test.pojo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component //注解的功能：使这个类被Spring接管，注册到容器中
public class User {
@Value("哈哈")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类：appConfig.class
package com.test.config;
import com.test.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration //这个也会被Spring容器托管，注册到容器中，因为他的类上面也有@Component是一个组件
//@Configuration 代表这个类是一个配置类，相当于之前的beans.xml
@ComponentScan("com.test.pojo") //扫描注解
@Import(appConfig2.class) //类似于xml中的导入多个bean.xml
public class appConfig {
//注册一个bean，就相当于之前在xml文件中配置的一个bean标签
//这个方法的方法名，就相当于bean标签中的id属性
//这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User(); //就是返回一个要注入到bean的对象。
}
}
//appConfig2类
package com.test.config;
import com.test.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration //这个也会被Spring容器托管，注册到容器中，因为他的类上面也有@Component是一个组件
//@Configuration 代表这个类是一个配置类，相当于之前的beans.xml
@ComponentScan("com.test.pojo") //扫描注解
public class appConfig2 {
//注册一个bean，就相当于之前在xml文件中配置的一个bean标签
//这个方法的方法名，就相当于bean标签中的id属性
//这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User user(){
return new User(); //就是返回一个要注入到bean的对象。
}
}
MyTest.class
import com.test.config.appConfig;
import com.test.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方式实现去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(appConfig.class);
User user = (User) context.getBean("getUser");
System.out.println(user.getName());
}
}
这种纯java配置的方式，在SpringBoot中随处可见。
浙公网安备 33010602011771号