Spring相关知识

1.背景

1.1 发展背景

Spring是一个2002年   首次推出Spring框架的雏形：interface21
 2004年3月24日 Spring框架基于interface框架

Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架

SSH：Struct2+Spring+Hibernate
SSM:SpringMVC+Spring+Mybatis

github:https://github.com/spring-projects/spring-framework

1.2优点

Spring是一个开源的免费的框架
Spring是一个轻量级、非入侵式的框架
控制反转（IOC）、面向切面编程（AOP）
支持事务的处理，对框架整合的支持

总结：Spring就是一个轻量级的控制反转(IOC)和面向切面编程（AOP)的框架！

1.3Spring组成

Spring AOP    Spring ORM(Hibernate support、IBats support、JDO )  
SpringDAO(dao jobc)   Spring WEB   Spring Context  ,spring web MVC
Spring Core

1.4扩展

现代化JAV开发
you app----Spring Boot(构建一切)----Spring cloud(协调一切)----Spring Cloud Data Flow(连接一切）

SpringBoot 
 一个快速开发的脚手架
基于SpringBoot可以快速的开发单个微服务
约定大于配置

Spring Cloud
SpringCloud是基于SPringBoot实现的

学习Spring以及Spring MVC

Spring的弊端：
配置十分繁琐

 

2.控制反转 IOC理论推导

UserDao接口

public interface UserDao{
	public void getUser();
}

UserDaoImpl实现类

Public class UserDaoImpl implements UserDao{
    @override
    public void getUser(){
        System.out.println（“获取用户信息”）；
}

UserService  业务接口

public interface UserService{
    void getUser();
}

UserServiceImpl业务实现类

public class UserServiceImpl implements UserService{
    private UserDao userDao=new UserDaoImpl();
    public void getUser(){
        userDao.getUser();
    }
}

用户调用的是业务层，dao层他们不需要接触

将UserServiceImpl业务实现类改成

public class UserServiceImpl implements UserService{
    private UserDao userDao;
//利用set动态实现值的注入
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }        
    //private UserDao userDao=new UserDaoImpl();
    public void getUser(){
        userDao.getUser();
    }
}

public static void main(String[] args){
    UserService userService=new UserServiceImpl();
    //((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
    ((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
    userService.getUser();
    }
}

我们使用一个Set的接口实现，已经发生了革命性的变化。
Private UserDao userDao;

//利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao){
  this.userDao=userDao;
}

之前，程序是主动创建对象，主动权在程序员手里
使用了set后，程序不在具有主动性，而是变成了被动的接收对象

这种思想，从本质上解决了问题，我们不用再去管理对象的创建了，系统的耦合性大大降低，
可以专注在业务上，这是ioc的原型。

用户---业务层---mysql.oracle
以前主动权在业务层（程序员手里），现在主动权在用户

IOC是Spring的核心内容，可以使用XML配置，也可以使用注解，
新版的Spring也可以零配置实现IOC

 控制反转是一种通过描述（XML或者注解）并通过第三方去生产或获取特定对象的方式。
在Spring中实现控制反转的是IOC容器，其实现方法是 依赖注入（Dependency Injection,DI)。

 

3.HelloSpring

public class Hello{
    private String str;
    public  String getStr(){
        return str;
    }
    public void setStr(String str){
        this.str=str;
    }
    @Override
    public String toString(){
        return "Hello{"+
                "str='"+str+'\''+'}';
    }
}

beans.xmls

<?xml version="1.0" encoding="UTF-8"?>
<!--此处beans标签下的配置不全,自己去看-->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<!--使用Spring来创建对象，在Spring这些都称为Bean,class写的是实体类的具体路径
    bean=对象
类型  变量名=new 类型();
Hello hello=new Hello();

id=变量名
class=new 的对象
property 相当于给属性设置
-->
<bean id="hello" class="com.kuang.poji.hello">
    <property name="str" value="Spring"/>
</bean>

</beans>

 

实例化容器

public class MyTest{    
    public static void main(String[] args){
//获取spring的上下文对象
        ApplicationContext context=new ClassPathXmlApplicationContext(...configLocation:"beans.xml");
//我们的对象现在都在spring中管理了，我们要使用，直接去里面取出来
Hello hello=(Hello)context.getBean("hello");
System.out.println(hello.toString());
//结果是  Hello{str='Spring'}
    }
}

这个过程叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而编程被动的接收对象。

依赖注入：就是利用set方法来进行注入的。

IOC是一种编程思想，由主动的编程变成被动的接收。

可以通过new ClassPathXmlApplicationContext去浏览一下底层源码

 

<bean id="mysqlImpl class="com.kuang.dao.UserDaoMysqlImpl"/>

<!--ref:Spring容器中创建好的对象
    value:具体的值，基本数据类型！-->
<bean id="UserServiceImpl" class="com.kuang.service.UserServiceImpl">
    <property name="userDao" ref="mysqlImpl"/>
</bean>

public class MyTest{    
    public static void main(String[] args){
//获取ApplicationContext ：拿到Spring的容器
        ApplicationContext context=new ClassPathXmlApplicationContext(...configLocation:"beans.xml");

//我们的对象现在都在spring中管理了，我们要使用，直接去里面取出来

UserServiceImpl userServiceImpl=(UserServiceImpl)context.getbean("UserServiceImpl");
userServiceImpl.getUser();
//结果是  Mysql获取用户数据
    }
}
 

 

IOC：对象由Spring来创建，管理，装配！

 

4.IOC创建对象的方式

1.使用无参构造创建对象

2.假设我们要使用有参构造创建对象

 a.下表赋值

<!--ref:Spring容器中创建好的对象
    value:具体的值，基本数据类型！-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="lianhua"/>
</bean>

b.类型复制（不建议使用）

<!--ref:Spring容器中创建好的对象
    value:具体的值，基本数据类型！-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="lianhua"/>
</bean>

 

c.通过参数名来赋值

<!--第三种方式：直接通过参数名来设置-->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="lianhua"/>
</bean>

 

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

5.Spring配置

5.1别名

<!--我们也可以通过别名获取到这个对象-->
<alias name="user" alias-"yonghu"/>

5.2bean配置

<!--id:bean的唯一标识符，也就是相当于我们学的对象名   
class:bean对象所对应的全限定名：包名+类型
name:也就是别名，而且name可以同时取多个别名-->
<bean id="user" class="com.kuang.pojo.User" name="user2 ,u2 u3;u4">
    <property name="name" value="hah"/>    
</bean>

5.3import

这个Import,一般用于团队开发使用，它可以将多个配置文件，导入合并为一个

假设，现有的项目中由多个人开发

applicationContext.xml

<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

使用的时候，直接使用总的配置就可以了

6.DI依赖注入

6.1构造器注入

当实体类由构造方法时，获取spring容器的时候，就会创造对象，就会运行构造方法

<bean id="user" class="com.kuang.pojo.User">
    <property name="name" value="hah"/>    
</bean>

6.2Set方式注入(重点)

依赖注入：Set注入！

    依赖：bean对象的创建依赖于容器！

    注入：bean对象中的所有属性，由容器来注入！

上图有get,set方法

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

此文章为《狂神说Java》视频后的笔记