【Java】Spring入门 vol1 Spring概述与Ioc

官网地址

https://spring.io/projects/spring-framework

下载地址

https://repo.spring.io/release/org/springframework/spring/

Github

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

Maven配置

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

<!--整合SpringJDBC-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

框架体系

• SSH
  Struts2 Spring Hibernate
• SSM
  SpringMVC Spring Mybatis

---

Spring优点

• 开源、免费、容器
• 轻量级、非入侵、
• 控制反转、面向切面
• 支持事务处理、框架整合

Spring是一个轻量级IOC和AOP的框架

控制反转（Inversion of Control，缩写为IoC）
是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。
其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），
还有一种方式叫“依赖查找”（Dependency Lookup）。
通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。
也可以说，依赖被注入到对象中。

切面编程AOP （Aspect Oriented Programming）
通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

---

Spring7大模块

构建-> 协调一切 -> 连接
现代化Java开发

• SpringBoot
  快速开发的工具 (单个微服务)
• SpringCloud
  基于SpringBoot实现

弊端:

• 违背初建理念 配置十分繁琐 配置地狱

---

IOC理论推导

Web实现步骤:
UserDao dao接口
UserDaoImpl 实现类
UserService 业务接口
UserServiceImpl 业务实现

以往的Service层写死了dao对象传递

 private UserDao userDao = new UserDaoImpl();

如果用户的需求情况多样，原始的Dao无法满足需求
对修改和维护的代价是极大的

所以采用了多态实现
传输什么对象交给了调用者决定，不受程序的影响

private UserDao userDao; 

public void setUserDao(UserDao userDao){
	this.userDao = userDao;
}

可以看出对象的主动权，从程序控制变成由开发者控制
这一种概念被称为控制反转

我们解放了对象的创建管理、系统的耦合拆开、
专注的重点是实现业务逻辑
这是Ioc的原型理念

获得依赖对象的方式反转了

---

原始的DAO

public interface UserDao {
    void getUser();
}

MySQL实现和Oracle实现

public class UserMysqlDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("mysql实现");
    }
}
public class UserOracleDapImpl implements UserDao{
    public void getUser() {
        System.out.println("Oracle实现");
    }
}

Serivce层和Impl

public interface UserService {
    void getUser();
}
-----------------------------------------------------------------------
public class UserServiceImpl implements UserService{
    private UserDao userDao ;
    
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    
    public void getUser(){
        userDao.getUser();
    }
}

配置SpringBean文件

src\main\resources\beans.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="UserMysqlDaoImpl" class="dao.UserMysqlDaoImpl"/>
    <bean id="UserOracleDaoImpl" class="dao.UserOracleDapImpl"/>
    
    <bean id="UserServiceImpl" class="service.UserServiceImpl">
        <!--ref 是引用Spring容器中创建好的对象value具体的值-->
        <property name="userDao" ref="UserOracleDaoImpl" />
    </bean>
</beans>

测试类

@Test
public void spring(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserServiceImpl user = (UserServiceImpl)context.getBean("UserServiceImpl");
    user.getUser();
}

源码不需要修改，通过配置文件即可实现对象变换

mysql实现

<property name="userDao" ref="UserMysqlDaoImpl" />
-----------------------------------------------------
mysql实现

oracle实现

<property name="userDao" ref="UserOracleDaoImpl" />
-----------------------------------------------------
oracle实现

---

Ioc创建方式:

默认无参构造

User类

@Data
@AllArgsConstructor
public class User {
    private String name;
    
    public User(){
        System.out.println(User.class + "的无参构造调用");
    }
    public void show(){
        System.out.println("name="+name);
    }
}

beans.xml & test

<bean id="user" class="pojo.User" >
    <!-- 仅有无参构造时 ，可以使用property为字段赋值-->
    <property name="name" value="hah"/>
</bean>
----------------------------------------------------------
@Test
public void newSpringUser(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User)context.getBean("user");
}
-----------------------------------------------------
class pojo.User的无参构造调用
name=hah

带参构造

@Data
@AllArgsConstructor
public class User {
    private String name;
 
    public void show(){
        System.out.println("name="+name);
    }
}

beans.xml & test

<bean id="user" class="pojo.User" >
    <!--带参构造 参数要求： 参数索引、值-->
    <constructor-arg index="0" value="呵呵"/>
</bean>
------------------------------------------------
@Test
public void newSpringUser(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User)context.getBean("user");
    user.show();
}
----------------------------------------------
name=呵呵

带参构造第三种

<bean id="user" class="pojo.User" >
    <constructor-arg name="name" value="呵呵"/>
</bean>

总结以下就是这三种方式

<bean id="user" class="pojo.User" >
	//第一种 无参构造 直接为字段赋值
	<property name="name" value="hah"/>
	//第二种 带参构造
    <constructor-arg index="0" value="呵呵"/>
	//第三种 带参构造
    <constructor-arg name="name" value="呵呵"/>
</bean>

从Spring上下文获取的对象是一样的

@Test
public void newSpringUser(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = (User)context.getBean("user");
    User user2 = (User)context.getBean("user");
    System.out.println(user == user2);
}
-----------------------------------------------------
true