Spring

最新推荐文章于 2024-04-25 13:16:20 发布

weixin_45947655

最新推荐文章于 2024-04-25 13:16:20 发布

阅读量70

点赞数

文章标签： spring java spring boot

本文链接：https://blog.csdn.net/weixin_45947655/article/details/120260793

版权

Spring

1. 简介

1.1 下载

下载地址：

官网：

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

Maven：

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.8</version>
</dependency>

1.2 概述

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

Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

1.3 组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efNuSrtz-1631497173990)(C:\Users\29608\AppData\Roaming\Typora\typora-user-images\image-20210910091730468.png)]

1.4 拓展

在Spring的官网有这个介绍：现代化的Java开发！说白就是基于spring的开发

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u4UeaZlv-1631497173993)(C:\Users\29608\AppData\Roaming\Typora\typora-user-images\image-20210910092120001.png)]

Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置！
Spring Cloud
- Spring Cloud是基于SpringBoot实现的。

大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

弊端：发展太久之后，违背了原来的理念！配置十分繁琐，人称“配置地狱”

2. IOC理论

UserDao接口
UserDaoImpl实现类
UserService业务接口
UserServiceImpl业务实现类

在之前的业务中，用户的需求可能会影响UserServiceImpl中的代码。在代码量庞大时，成本将十分巨大。

使用一个set接口实现回避问题将会发生在UserServiceImpl中，转而在运行时，面向用户时可更改。

//UserServiceImpl
private UserDao userDao;

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

//运行程序的class
UserService userService = new UserServiceImpl();

        ((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
//运行程序的class

之前，程序是主动创建对象！控制权在程序员手上
使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！

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

3. Hello Spring

第一步：配置maven

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

第二步：编写Dao和Service

Dao：

package com.example.springstudy.dao;

public interface UserDao {
    void getUser();
}


package com.example.springstudy.dao;

public class UserDaoImpl implements UserDao{

    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}


package com.example.springstudy.dao;

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Mysql获取用户数据!");
    }
}


package com.example.springstudy.dao;

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户数据!");
    }
}


package com.example.springstudy.dao;

public class UserDaoSqlserviceImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Sqlservice获取用户数据!");
    }
}

Service：

package com.example.springstudy.service;

public interface UserService {

    void getUser();

}


package com.example.springstudy.service;

import com.example.springstudy.dao.UserDao;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

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

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

第三步：在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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
<!--每一个bean都连接一个实现类-->
    <bean id="userdao" class="com.example.springstudy.dao.UserDaoImpl"></bean>
    <bean id="mysql" class="com.example.springstudy.dao.UserDaoMysqlImpl"></bean>
    <bean id="orcale" class="com.example.springstudy.dao.UserDaoOracleImpl"></bean>
    <bean id="sqlservice" class="com.example.springstudy.dao.UserDaoSqlserviceImpl"></bean>
	<!--你可以在bean中定义类的属性，普通赋值用value，引用bean赋值类可以用ref-->
    <bean id="userservice" class="com.example.springstudy.service.UserServiceImpl">
        <property name="userDao" ref="mysql"></property>
    </bean>

</beans>

第四步：最终运行

import com.example.springstudy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {
        
        //此处引出bean.xml的工具
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        
        //利用工具使用每一个bean即实现类
        UserService userService = (UserService) context.getBean("userservice");
        userService.getUser(); 
    }
}

回过头来重新看一下定义：

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

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

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

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

我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC就是：对象由Spring来创建，管理，装配！

4. IOC创建对象方式

4.1 IOC默认使用无参构造

虽然我们知道了如何使用spring创建并使用一个对象，但它是如何创建一个对象的呢？调用该类的无参构造进行创建吗？

我们进行一个测试：

User：

package com.xuanjie.pojo;

public class User {

    private String name;

//    public User(String name){
//        this.name = name;
//    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("name="+name);
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="hello" class="com.xuanjie.pojo.User">
        <property name="name" value="许安杰---浙江师范大学"></property>
    </bean>

</beans>

运行代码：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("hello");
        user.show();
    }
}

在我们不使用有参构造的情况下，正常输出了结果，但当我们把User类中有参构造的注释删去之后，默认无参构造由于有参构造的存在而失效。这时再运行，发现报错了:

Instantiation of bean failed;

故结论得以证明，在类中没有声明任何构造方法时，beans.xml默认使用无参构造创建对象。

4.2 IOC如何使用有参构造

要想使用有参构造可以使用以下三种方法在beans.xml中配置

我们先将有参构造的参数增加一个，这样举例更详细一些。

public User(String name, int id) {
    this.name = name;
    this.id = id;
}

1.下标赋值

<bean id="hello" class="com.xuanjie.pojo.User">
    <constructor-arg index="0" value="许安杰---浙江师范大学"></constructor-arg>
    <constructor-arg index="1" value="153"></constructor-arg>
</bean>

2.类型

<bean id="hello" class="com.xuanjie.pojo.User">
    <constructor-arg type="java.lang.String" value="许安杰---浙江师范大学"></constructor-arg>
    <constructor-arg type="int" value="153"></constructor-arg>
</bean>

3.参数名

<bean id="hello" class="com.xuanjie.pojo.User">
    <constructor-arg name="name" value="许安杰---浙江师范大学"></constructor-arg>
    <constructor-arg name="id" value="153"></constructor-arg>
</bean>

额外一点：

在beans.xml中列出的多个bean会同时被全部创建。

也就是说，即使你程序运行时仅仅调用了beans.xml中一个类的对象，但其他在beans.xml中你没有调用的类，他们的对象依然被创建好了。只是在那摆着，但全部都通过构造函数创建好了。

5. Spring的xml配置

5.1 别名

alias为别名，两个名字都可以使用

<alias name="hello" alias="user"></alias>

5.2 Bean的配置

在bean中的name也是另起别名

<bean id="hello" class="com.xuanjie.pojo.User" name="user2">
    <constructor-arg name="name" value="许安杰---浙江师范大学"></constructor-arg>
    <constructor-arg name="id" value="153"></constructor-arg>
</bean>

5.3 importA

当你在资源目录下创建了多个beanA时，在bean-A中加入import对其他bean进行引用，则调用这个bean-A时，也可以调用被这个bean-A引用的其他bean中的内容。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

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

</beans>

6. 依赖注入

6.1 构造器注入

6.2 set方式注入

6.3 拓展方式注入

schema/beans"
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=“http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd”>

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

```

6. 依赖注入

6.1 构造器注入

6.2 set方式注入

6.3 拓展方式注入

weixin_45947655

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring

文章目录Spring1. 简介1.1 下载1.2 概述1.3 组成1.4 拓展2. IOC理论3. Hello Spring4. IOC创建对象方式4.1 IOC默认使用无参构造4.2 IOC如何使用有参构造5. Spring的xml配置5.1 别名5.2 Bean的配置5.3 importA6. 依赖注入6.1 构造器注入6.2 set方式注入6.3 拓展方式注入6. 依赖注入6.1 构造器注入6.2 set方式注入6.3 拓展方式注入Spring1. 简介1.1 下载下载地址：官网：ht
复制链接

扫一扫