一、Spring框架概念
1.什么是OCP?
OCP是软件七大开发原则当中最基本的一个原则:开闭原则
对什么开?对扩展开放。
对什么闭?对修改关闭。
OCP原则是最核心的,最基本的,其他的六个原则都是为这个原则服务的。
OCP开闭原则的核心是什么?
只要你在扩展系统功能的时候,没有修改以前写好的代码,那么你就足符合OCP原则的。
反之,如果在扩展系统功能的时候,你修改了之前的代码,那么这个设计是大败的,违背OCP原则。
进行系统功能扩展的时候,如果动了之前稳定的程序,修改了之前的程序,这前斯有程序都需要进行重新测试。这是不想看到的,因为非常麻烦。
2.依赖倒置原则(DIP原则)
什么是依赖倒置原则?
面向接口编程,面向抽象编程,不要面向具体编程。
依赖倒置原则的目的:降低程序的耦合度,提高扩展力。
什么叫做符合依赖倒置?
上不依赖 下,就是符合火 什么叫做违背依赖倒置?
上 依赖 下,就是违背。
只要“下”一改动,“上”就受到牵连。
3.当前程序的设计,显然既违背OCP,又违背DIP,怎么办?
以采用“控制反转”这种编程思想来解决这个问题。控制反转(IoC)
4.控制反转(IoC)
反转是什么呢?
反转的是两件事:
第一件事:我不在程序中采用硬编码的方式来new对象了。(new对象我不管了,new对象的权利交出去了。)
第二件事:我不在程序中采用硬编码的方式来维护对象的关系了。(对象之间关系的维护权,我也不管了,交出去了。)
控制反转: 是一种编程思想。或者叫做一种新型的设计模式。由于出现的比较新,没有被纳入GoF23种设计模式范围内。
5.Spring框架
Spring框架实现了控制反转IoC这种思想Spring框架可以帮你new对象。
Spring框架可以帮你维护对象和对象之间的关系。Spring是一个实现了IoC思想的容器。
控制反转的实现方式有多种,其中比较重要的叫做:依赖注入(Dependency Injection,简称DI)。
控制反转是思想。依赖注入是这种思想的具体实现。
依赖注入DI,又包括常见的两种方式:
第一种:set注入(执行set方法给属性赋值)
第二种:构造方法注入(执行构造方法给属性赋值)
依赖注入 中“依赖”是什么意思?“注入“是什么意思?依赖:A对象和B对象的关系。注入:是一种手段,通过这种手段,可以让A对象和B对象产生关系
Spring有两个核心部分:IOC 和Aop.
(1) IOC:控制反转,把创建对象过程交给 Spring 进行管理
(2) Aop:面向切面,不修改源代码进行功能增强
二、Spring入门程序
先在这个程序中pom.xml中引入依赖配置
<!--依赖-->
<!--当你引入Spring Context 依赖之后,表示将Spring的基础依赖引入了-->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.0-M2</version>
</dependency>
<!--junit依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
在主程序(main)中引入一个类
package com.hei;
public class User {
}
在resources下创建Spring的配置文件,放在resources根目录下,相当于放到了类的根路径下。配置bean。这样spring才能帮助我们管理这个对象。
bean标签的两个重要属性:id:这个bean的身份证号,不能重复,唯一标识。class:必须填写类的全路径,全限定类名(带包名的类名)。
<bean id="Userbean" class="com.hei.User"/>
</beans>
在test下引入测试类,第一步:获取Spring容器对象。这段代码相当于启动了Spring容器,解析spring.xml文件,并实例化所用的bean对象,放在spring容器中。
第二步:根据bean的id从Spring容器获取这个对象。
package com.heit;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class springtest {
@Test
public void springtest() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
Object obj = applicationContext.getBean("Userbean");
System.out.println(obj);
}
}
三、Spring对IoC的实现
1.IoC控制反转
控制反转是一种思想,依赖注入是实现方式。
2.依赖注入
1)set依赖注入
set依赖注入是基于set方法进行的,要用set依赖注入必须在配置文件中(spring.xml),配置<property name="" ref=""/>
先在主函数中写类与方法:
创建一个UserDao类:
package com.hei.dao;
public class UserDao {
public void insert(){
System.out.println("数据库正在保存信息");
}
}
创建一个UserService类:
在UserService类中要调用UserDao方法,需创建UserDao的对象,还需要对UserDao进行set赋值。可以利用IDEA自动生成set方法,也可以自己书写。
package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
private UserDao ud;//创建引用数据类型
//set注入的话,必须提供一个set方法
public void setMysqlUser(UserDao u){//set方法
this.ud=u;
}
public void Save(){//创建一个方法调用UserDao对象
ud.insert();
}
}
在配置文件(spring.xml)中进行配置bean和property:
<bean id="userdao" class="com.hei.dao.UserDao"/>
<bean id="userservice" class="com.hei.servece.UserService">
<!--要想让Spring调用set方法,必须要用property配置-->
<!--name:为set方法的方法名 -->
<!--ref:为引用,ref后面指定的是要注入的bean的id -->
<property name="mysqlUser" ref="userdao">
</property>
</bean>
在测试类中进行演示:
package com.hei;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
UserService us=applicationContext.getBean("userservice",UserService.class);
us.Save();
}
}
2)构造注入
利用构造方法进行。在配置文件(spring.xml)中有三种配置构造方法。
创建一个UserDao类:
package com.hei.dao;
public class UserDao {
public void insert(){
System.out.println("数据正在保存信息为构造注入");
}
}
创建一个UserService类:
在UserService类中要调用UserDao方法,需创建UserDao的对象,还需进行构造方法赋值。
package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
//构造注入
private UserDao userdao;//引用数据类型
public UserService(UserDao userdao) {//构造方法
this.userdao = userdao;
}
public void save(){
userdao.insert();
}
}
在配置文件(spring.xml)中进行配置bean和constructor-arg:
<bean id="userdao" class="com.hei.dao.UserDao"/>
<bean id="userService1" class="com.hei.servece.UserService">
<!--构造注入-->
<!--
index属性指定参数下标,第一个参数是0,第二个参数是1等等
ref属性用来指定注入的bean的id
-->
<!--利用下标构造方式-->
<constructor-arg index="0" ref="userdao"></constructor-arg>
</bean>
<bean id="userService2" class="com.hei.servece.UserService">
<!--利用名字构造-->
<constructor-arg name="userdao" ref="userdao">
</constructor-arg>
</bean>
<bean id="userService3" class="com.hei.servece.UserService">
<!--直接构造,让程序直接匹配对象类别-->
<constructor-arg ref="userdao"></constructor-arg>
</bean>
在主函数测试类中:
package com.hei;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
//第一种方法
UserService use1= applicationContext.getBean("userService1",UserService.class);
use1.save();
System.out.println("------------");
//第二种方法
UserService use2= applicationContext.getBean("userService2",UserService.class);
use2.save();
System.out.println("---------------");
//第三种方法
UserService use3= applicationContext.getBean("userService3",UserService.class);
use3.save();
3.set注入专题
1)内部bean与外部bean
在Dao包下:
package com.hei.dao;
public class Order {
public void insert(){
System.out.println("这是订购信息");
}
}
在service包下:
package com.hei.service;
import com.hei.dao.Order;
public class OderService {
private Order ord;//引用数据类型
public void setOrd(Order ord) {
this.ord = ord;
}
public void generate(){
ord.insert();
}
}
在配置文件(spring.xml)中:
<!--外部bean-->
<bean id="order" class="com.hei.dao.Order"/>
<bean id="orders1" class="com.hei.servece.OderService">
<property name="ord" ref="order">
</property>
</bean>
<!--内部bean-->
<bean id="orders2" class="com.hei.servece.OderService">
<property name="ord">
<bean class="com.hei.dao.Order"></bean>
</property>
</bean>
2)简单注入
简单类:8种基本类型、8种包装类、枚举、Class、Date类型都是简单数据类型。在实际开发中,不会将Date类型看作是简单数据类型,虽然他本质上是简单数据类型,用ref进行赋值。
简单注入采用value进行赋值。
Dao包中的User类:
package com.hei.dao;
public class User {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
在配置文件(spring.xml)中:
<!--简单注入-->
<bean id="user" class="com.hei.dao.User">
<property name="name" value="张三"/>
<property name="age" value="23"></property>
</bean>
测试类中:
package com.hei;
import com.hei.dao.User;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User u= applicationContext.getBean("user", User.class);
System.out.println(u);
}
}
3)级联属性赋值
使用级联属性赋值:需要在使用的属性配置get方法
clazz班级类:
package com.hei.dao;
public class clazz {
private String cname;
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "clazz{" +
"cname='" + cname + '\'' +
'}';
}
}
Student学生类:
package com.hei.dao;
public class Student {
private String name;
private int age;
private clazz c;//学生所在班级
public void setC(clazz c) {
this.c = c;
}
public clazz getC() {
return c;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", c=" + c +
'}';
}
}
配置文件(spring.xml):
<!--级联赋值-->
<bean id="student" class="com.hei.dao.Student">
<property name="name" value="张三"/>
<property name="age" value="18"/>
<property name="c" ref="clazz"/>
<property name="c.cname" value="高一一班"></property>
</bean>
<bean id="clazz" class="com.hei.dao.clazz"></bean>
测试类:
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Student s=applicationContext.getBean("student", Student.class);
System.out.println(s);
}
}
4)数组注入
简单类型赋值时用value,复杂类型赋值时,用ref。
Student学生类:
package com.hei.dao;
import java.util.Arrays;
public class Student {
private String[] hobby;
public void setHobby(String[] hobby) {
this.hobby = hobby;
}
@Override
public String toString() {
return "Student{" +
"hobby=" + Arrays.toString(hobby) +
'}';
}
}
配置文件(spring.xml):
id:为标志,可以随意起,有唯一性。
class:为所在地址。
name:为set方法后面的方法名(setHobby 这位hobby)
<bean id="hobby" class="com.hei.dao.Student">
<property name="hobby">
<array>
<value>打游戏</value>
<value>学习</value>
<value>睡觉</value>
</array>
</property>
</bean>
测试类:
getbean中的字符串为:配置文件中的id号
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Student s=applicationContext.getBean("hobby", Student.class);
System.out.println(s);
}
}
当数组不是简单类型,例如:
其中w1等等为bean中的id号。
5)List集合和Set集合注入
User类:
package com.hei.dao;
import java.util.List;
import java.util.Set;
public class User {
private List<String> list;
private Set<String> set;
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
@Override
public String toString() {
return "User{" +
"list=" + list +
", set=" + set +
'}';
}
}
<bean id="u1" class="com.hei.dao.User">
<property name="list">
<list>
<value>张三</value>
<value>李四</value>
</list>
</property>
<property name="set">
<set>
<value>王五</value>
<value>赵六</value>
</set>
</property>
</bean>
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
User u=applicationContext.getBean("u1", User.class);
System.out.println(u);
}
}
6)Map集合注入和propertise注入
propertise是一个属性类,本质上是一个map集合,它的键值对的属性只能是String类型。
User类:
package com.hei.dao;
import java.util.Map;
import java.util.Properties;
public class User {
private Map<String,Integer> s;
private Properties p;
public void setS(Map<String, Integer> s) {
this.s = s;
}
public void setP(Properties p) {
this.p = p;
}
@Override
public String toString() {
return "User{" +
"s=" + s +
", p=" + p +
'}';
}
}
spring.xml:
<bean id="u1" class="com.hei.dao.User">
<property name="s">
<map>
<entry key="张三" value="23"/>
<entry key="李四" value="24"/>
</map>
</property>
<property name="p">
<props>
<prop key="wangwu">root</prop>
<prop key="hostall">lib</prop>
</props>
</property>
</bean>
测试类:
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
User u=applicationContext.getBean("u1", User.class);
System.out.println(u);
}
}
7)注入null和空字符串
注入null:不给属性赋值,属性默认值就是null。
Cat类:
package com.hei.dao;
public class Cat {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
spring.xml:
注入null:不给属性赋值,属性默认值就是null。
手动注入null:<null/>
注入空字符串:<value/>
<bean id="mao" class="com.hei.dao.Cat">
<!--注入null-->
<!-- <property name="name" value="蓝金渐层"></property>-->
<!--手动注入null-->
<!-- <property name="name">-->
<!-- <null/>-->
<!-- </property>-->
<!-- 注入空字符串-->
<!-- <property name="name" value=""></property>-->
<!-- 手动注入空字符串-->
<property name="name">
<value/>
</property>
<property name="age" value="5"></property>
</bean>
测试类:
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Cat c=applicationContext.getBean("mao",Cat.class);
System.out.println(c);
}
}
8)注入特殊符号
package com.hei.dao;
public class Clazz {
private String result;
public void setResult(String result) {
this.result = result;
}
@Override
public String toString() {
return "clazz{" +
"result='" + result + '\'' +
'}';
}
}
<bean id="r" class="com.hei.dao.Clazz">
<property name="result" value="2 <3"></property>
</bean>
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Clazz c =applicationContext.getBean("r",Clazz.class);
System.out.println(c);
}
}
4.p命名空间注入
简化set注入的一种方式,底层仍是set注入。在Spring配置头部添加p命名空间,使用p:属性名=“属性值”
package com.hei.dao;
import java.util.Date;
public class Cat {
private String name;
private int age;
private Date birth;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", age=" + age +
", birth=" + birth +
'}';
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 在Spring配置头部添加p命名空间-->
<!-- 使用p:属性名=“属性值”-->
<bean id="mao" class="com.hei.dao.Cat" p:name="小猫猫" p:age="3" p:birth-ref="birthday"></bean>
<bean id="birthday" class="java.util.Date"></bean>
</beans>
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Cat c =applicationContext.getBean("mao",Cat.class);
System.out.println(c);
}
}
5.c命名空间注入
简化构造方法的一种注入方法。
package com.hei.dao;
public class Dog {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="d" class="com.hei.dao.Dog" c:_0="柯基" c:_1="2"></bean>
</beans>
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
Dog dog =applicationContext.getBean("d",Dog.class);
System.out.println(dog);
}
}
6.基于XML自动装配
自动化注入也叫做自动化装配,底层仍是set方法,分两种类型,一种是:通过名字,一种是:通过类型。
通过名字byName
Order类:
package com.hei.dao;
public class Order {
public void insert(){
System.out.println("这是订购信息");
}
}
OrderSerivice类:
package com.hei.servece;
import com.hei.dao.Order;
public class OderService {
private Order ord;
public void setOrd(Order ord) {
this.ord = ord;
}
public void generate(){
ord.insert();
}
}
spring.xml:
<bean id="select" class="com.hei.servece.OderService" autowire="byName"></bean>
<!-- 这个ID的名字不能乱写,应为set方法的名字(取掉set方法名和第一个大写字母变小写-->
<bean id="ord" class="com.hei.dao.Order"></bean>
测试类:
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
OderService o =applicationContext.getBean("select",OderService.class);
o.generate();
}
}
通过类型byType
UserDao类:
package com.hei.dao;
public class UserDao {
public void insert(){
System.out.println("数据正在保存信息");
}
}
UserService类:
package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
private UserDao user;
public void setUser(UserDao user) {
this.user = user;
}
public void save(){
user.insert();
}
}
spring.xml:
<bean class="com.hei.dao.UserDao"></bean>
<bean id="user" class="com.hei.servece.UserService" autowire="byType"></bean>
测试类:
public class Test {
@org.junit.Test
public void TestDao() {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
UserService u =applicationContext.getBean("user",UserService.class);
u.save();
}
}