Spring学习笔记

最新推荐文章于 2024-09-03 21:54:02 发布
最新推荐文章于 2024-09-03 21:54:02 发布
阅读量136 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eimhin_Tang/article/details/108726239
版权

1、Spring

1.1 简介

  • Spring：春天—给软件行业带来了春天

  • 2002, 首次推出了Spring框架的雏形: interface21框架.

  • Spring框架即以interface21框架为基础, 经过重新设计, 并不断丰富其内涵, 于2004年3月24日, 发布了1.0正式版.

  • Rod Johnson, Spring Framework创始人, 著名作者. 悉尼大学音乐学博士.

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

  • SSH: Struct2 + Spring + Hibernate

  • SSM: SpringMVC + Spring + MyBatis

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

官方下载地址: https://repo.spring.io/release/org/springframework/spring/

Github地址: https://github.com/spring-projects/spring-framework

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

1.2 优点

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

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

1.3 Spring的组成

1.4 扩展

现代化的Java开发, 说白了就是基于Spring的开发

Spring Boot: 构建一切

Spring Cloud: 协调一切

Spring Cloud Data Flow: 连接一切

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

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

弊端: 发展了太久之后, 违背了原来的理念. 配置十分繁琐, 人称"配置地狱"

2、IOC理论推导

  1. UserDao接口
public interface UserDao {
    void getUser();
}
  1. UserDaoImpl实现类
public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}
  1. UserService业务接口
public interface UserService {
    void setUserDao(UserDao userDao);
    void getUser();
}
  1. UserServiceImpl业务实现
public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    public void getUser() {
        userDao.getUser();
    }
}

在之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码。如果程序代码量十分大，修改一次的成本代价十分昂贵。

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

private UserDao userDao;
// 利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
  • 之前，程序是主动创建对象，控制权在程序员手上。
  • 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象。

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

IOC本质

控制反转loC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现loC的一种方法，也有人认为DI只是loC的另一种说法。没有loC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所调控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

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

3、Hello Spring

  1. 编写实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Hello {
    private String str;
}
  1. 编写配置文件 applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="hello" class="com.tangyixing.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>
  1. 编写测试代码
public class MyTest {
    public static void main(String[] args) {
        // 获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 我们的对象现在都在Spring中管理了, 我们要使用, 直接去里面取出来就可以
        Hello hello = (Hello)context.getBean("hello");
        System.out.println(hello.toString());
    }
}

修改第一个程序的代码, 改成用Spring实现.

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="mysqlImpl" class="com.tangyixing.dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.tangyixing.dao.UserDaoOracleImpl"/>
    <bean id="sqlserverImpl" class="com.tangyixing.dao.UserDaoSqlserverImpl"/>
    <bean id="UserServiceImpl" class="com.tangyixing.service.UserServiceImpl">
        <property name="userDao" ref="sqlserverImpl"/>
    </bean>
</beans>

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)context.getBean("UserServiceImpl");
        userService.getUser();
    }
}

思考问题

  • Hello对象是谁创建的?

    Hello对象是由Spring创建的

  • Hello对象的属性是怎么设置的

    Hello对象的属性是由Spring容器设置的

这个过程就叫控制反转

控制: 谁来控制对象的创建, 传统应用程序的对象是由程序本身控制创建的, 使用Spring后, 对象是由Spring来创建的.

反转: 程序本身不创建对象, 而变成被动的接收对象.

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

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

彻底不用再去程序中去改动了, 要实现不同的操作, 只需要再xml配置文件中进行修改, 所谓的IOC, 一句话: 对象由Spring来创建, 管理, 装配.

4、IOC创建对象的方式

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

  2. 假设要使用有参构造创建对象 (不需要显式写无参构造)

    1. 下标赋值

      <bean id="user" class="com.tangyixing.pojo.User">
    <constructor-arg index="0" value="tyx"/>
</bean>

    2. 类型 (不建议, 如有许多相同类型的)

      <bean id="user" class="com.tangyixing.pojo.User">
    <constructor-arg type="java.lang.String" value="tangyixing"/>
</bean>

    3. 参数名

      <bean id="user" class="com.tangyixing.pojo.User">
    <constructor-arg name="name" value="唐毅兴"/>
</bean>

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

5、Spring配置

5.1 别名

<!-- 如果添加了别名, 也可以使用别名获取到这个对象 -->
<alias name="user" alias="userNew"/>

5.2 Bean的配置

<!--
    id: bean的唯一标识符, 也就是相当于对象名
    class: bean对象所对应的全限定名: 包名 + 类名
    name: 也是别名, 而且name可以同时取多个别名, 可以用逗号, 空格, 分号分割
    -->
<bean id="userT" class="com.tangyixing.pojo.UserT" name="user2 u2,u3;u4">
    <property name="name" value="Eimhin"/>
</bean>

5.3 import

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

假设现在项目中有多个人开发, 这三个人复制不同的类开发, 不同的类需要注册在不同的bean中, 我们可以利用import将所有人的beans.xml合并为一个总的.

  • 张三

  • 李四

  • 王五

  • applicationContext.xml

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

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

6、DI依赖注入

6.1 构造器注入

参考4

6.2 Set方式注入【重点】

  • 依赖注入：Set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性, 由容器来注入

环境搭建

  1. 复杂类型

    @Data
public class Address {
    private String address;
}

  2. 真实测试对象

    @Data
public class Student {
    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;
    private Properties info;
}

  3. applicationContext.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="student" class="com.tangyixing.pojo.Student">
        <!-- 第一种, 普通值注入, value -->
        <property name="name" value="唐毅兴"/>
    </bean>
</beans>

  4. 测试类

    public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
        System.out.println(student.getAddress());
    }
}

完善注入信息

<?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="address" class="com.tangyixing.pojo.Address">
        <property name="address" value="杭州市富阳区"/>
    </bean>

    <bean id="student" class="com.tangyixing.pojo.Student">
        <!-- 普通值注入, value -->
        <property name="name" value="唐毅兴"/>
        <!-- bean注入, ref -->
        <property name="address" ref="address"/>
        <!-- 数组注入, array -->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</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="身份证" value="330183123456789011"/>
                <entry key="银行卡" value="111111111111111111"/>
            </map>
        </property>
        <!-- Set -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!-- null -->
        <property name="wife">
            <null/>
        </property>
        <!-- Properties -->
        <property name="info">
            <props>
                <prop key="driver">jdbc</prop>
                <prop key="url">localhost</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>

</beans>

6.3 拓展方式注入

可以使用p命名控件和c命名控件进行注入

applicationContext.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- p命名空间注入, 可以直接注入属性的值 -->
    <bean id="user" class="com.tangyixing.pojo.User" p:name="唐毅兴" p:age="22"/>
    <!-- c命名空间注入, 可以通过构造器注入:constructor -->
    <bean id="user2" class="com.tangyixing.pojo.User" c:name="tyx" c:age="21"/>
</beans>

测试类

@Test
public void test() {
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

注意点:p命名空间和c命名空间不能直接使用, 需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.4 bean的作用域

  1. 单例模式(Spring默认机制)

    <bean id="user2" class="com.tangyixing.pojo.User" c:name="tyx" c:age="21" scope="singleton"/>

  2. 原型模式: 每次从容器中get的时候, 都会产生一个新对象。

    <bean id="user2" class="com.tangyixing.pojo.User" c:name="tyx" c:age="21" scope="prototype"/>

  3. 其余的request, session, application, 这些只能在web开发中使用到

7、Bean的自动装配

  • 自动装配是Spring满足bean依赖的一种方式
  • Spring会在上下文中自动寻找，并自动 给bean装配属性

在Spring中有三种装配的方式

  1. 在xml中显式的配置
  2. 在java中显式配置
  3. 隐式的自动装配bean【重要】

7.1 测试

环境搭建：一个人有两个宠物

@Data
public class People {
    private Cat cat;
    private Dog dog;
    private String name;
}

<?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="cat" class="com.tangyixing.pojo.Cat"/>
    <bean id="dog" class="com.tangyixing.pojo.Dog"/>
    <bean id="people" class="com.tangyixing.pojo.People">
        <property name="name" value="tyx"/>
        <property name="dog" ref="dog"/>
        <property name="cat" ref="cat"/>
    </bean>
</beans>

7.2 ByName自动装配

<?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="cat" class="com.tangyixing.pojo.Cat"/>
    <bean id="dog" class="com.tangyixing.pojo.Dog"/>
    <!--
    byName: 会自动在容器上下文中查找, 和自己对象set方法后面的值对应的beanid.
    -->
    <bean id="people" class="com.tangyixing.pojo.People" autowire="byName">
        <property name="name" value="tyx"/>
    </bean>
</beans>

7.3 ByType自动装配

<?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="cat111" class="com.tangyixing.pojo.Cat"/>
    <!-- 使用byType, id可以省略 -->
    <bean class="com.tangyixing.pojo.Dog"/>
    <!--
    byName: 会自动在容器上下文中查找, 和自己对象set方法后面的值对应的beanid.
    byType: 会自动在容器上下文中查找, 和自己对象属性类型相同的beanid.
    -->
    <bean id="people" class="com.tangyixing.pojo.People" autowire="byType">
        <property name="name" value="tyx"/>
    </bean>
</beans>

小结:

  • byName的时候, 需要保证所有bean的id唯一, 并且这个bean需要和自动注入的属性的set方法的值一致.
  • byType的时候, 需要保证所有bean的class唯一, 并且这个bean需要和自动注入的属性的类型一致.

7.4 使用注解实现自动装配

jdk1.5支持的注解, Spring2.5就支持注解了

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

要使用注解须知:

  1. 导入约束, context约束

  2. 配置注解的支持 <context:annotation-config/>

    <?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/>

</beans>

@Autowired

直接在属性上使用即可, 也可以在set方法上使用.

使用Autowired我们可以不用编写set方法了, 前提是这个自动装配的属性在IOC(Spring)容器中存在, 且符合类型byType.

<?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/>
    <bean id="cat" class="com.tangyixing.pojo.Cat"/>
    <bean id="dog" class="com.tangyixing.pojo.Dog"/>
    <bean id="people" class="com.tangyixing.pojo.People"/>
</beans>

@Data
public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

科普:

// @Nullable	字段标记了这个注解, 说明这个字段可以为null
public People(@Nullable String name) {
    this.name = name;
}

// 如果显式定义了Autowired的required属性为false, 说明这个对象可以为null, 否则不允许为空
@Autowired(required = false)
private Cat cat;

如果@Autowired自动装配的环境比较复杂, 自动装配无法通过一个注解@Autowired完成的时候, 我们可以使用@Qualifier(value = "xxx")去配合@Autowired的使用, 指定一个唯一的bean对象注入.

@Data
public class People {
    @Autowired
    @Qualifier(value = "cat11")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;
}

@Resource

@Data
public class People {
    @Resource(name = "cat1")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
}

小结:

@Resource 和 @Autowired 的区别:

  • 都是用来自动装配的, 都可以放在属性字段上
  • @Autowired 默认通过byType的方式实现, 而且必须要求这个对象存在.
  • @Resource 默认通过byName的方式实现, 如果找不到名字, 则通过byType实现, 如果两个都找不到的情况下, 就报错, 使用 @Resource(name = "xxx") 解决 【常用】
  • 执行顺序不同：@Autowired 通过byType的方式实现。@ Resource 默认通过byName的方式实现

8、使用注解开发

在Spring4之后, 要使用注解开发, 必须要保证aop的包导入了.

使用注解需要导入context约束, 增加注解的支持.

<?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:component-scan base-package="com.tangyixing"/>
    <context:annotation-config/>

</beans>

  1. bean

  2. 属性如何注入

    // 相当于 <bean id="user" class="com.tangyixing.pojo.User"/>
// @Component 组件
@Component
@Data
public class User {
    // 相当于 <property name="name" value="tangyixing"/>
    @Value("tangyixing")
    private String name;
}

  3. 衍生的注解

    @Component有几个衍生注解, 我们在web开发中, 会按照mvc三层架构分层.

    • dao @Repository
    • service @Service
    • controller @Controller

    这四个注解功能都是一样的, 都是代表将某个类注册到Spring中, 装配Bean

  4. 自动装配注解

    • @Autowired
    • @Nullable
    • @Resource

  5. 作用域

    @Scope("singleton")	// 单例模式
@Scope("prototype")	// 原型模式

  6. 小结

    xml 与 注解:

    • xml 更加万能, 适用于任何场合. 维护简单方便
    • 注解 不是自己的类使用不了, 维护相对复杂

    xml 与 注解 最佳实践:

    • xml用来管理bean

    • 注解只负责完成属性的注入

    • 我们在使用的过程中, 只需要注意一个问题: 必须让注解生效, 就需要开启注解的支持

      <!-- 指定要扫描的包, 这个包下的注解就会生效 -->
<context:component-scan base-package="com.tangyixing"/>
<context:annotation-config/>

9、使用Java的方式配置Spring

我们现在要完全不使用Spring的xml配置了, 全权交给Java来做

JavaConfig是Spring的一个子项目, 在Spring4之后, 它成为了一个核心功能.

实体类

@Data
// 这里这个注解的意思, 就是说明这个类被Spring接管了, 注册到了容器中
@Component
public class User {
    @Value("唐毅兴")   // 属性注入值
    private String name;
}

配置文件

// 这个也会被Spring容器托管, 注册到容器中, 因为他本来就是一个@Component
// @Configuration代表这是一个配置类, 就和我们之前看的applicationContext.xml一样
@Configuration
@ComponentScan("com.tangyixing.pojo")
@Import(TangConfig2.class)
public class TangConfig {
    // 注册一个bean, 就相当于我们之前写的一个bean标签
    // 这个方法的名字, 就相当于bean标签中的id属性
    // 这个方法的返回值, 就相当于bean标签中的class属性
    @Bean
    public User user() {
        return new User();  // 就是返回要注入到bean的对象
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        // 如果完全使用了配置类方式去做, 我们就只能通过 AnnotationConfig 上下文来获取容器, 通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(TangConfig.class);
        User getUser = context.getBean("user", User.class);
        System.out.println(getUser.getName());
    }
}

这种纯Java的配置方式, 在SpringBoot中随处可见

10、代理模式

为什么要学习代理模式？因为这就是Spring AOP的底层。

代理模式的分类：

  • 静态代理
  • 动态代理

10.1 静态代理

角色分析：

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，一般会做一些附属操作
  • 客户：访问代理对象的人

代码步骤：

  1. 接口

    // 租房
public interface Rent {
    void rent();
}

  2. 真实角色

    // 房东
public class Host implements Rent {
    public void rent() {
        System.out.println("房东要出租房子!");
    }
}

  3. 代理角色

    @Data
@NoArgsConstructor
public class Proxy implements Rent {
    private Host host;
    public Proxy(Host host) {
        this.host = host;
    }
    public void rent() {
        seeHouse();
        host.rent();
        hetong();
        fare();
    }
    // 看房
    public void seeHouse() {
        System.out.println("中介带你看房");
    }
    // 签合同
    public void hetong() {
        System.out.println("签租赁合同");
    }
    // 收中介费
    public void fare() {
        System.out.println("收中介费");
    }
}

  4. 客户端访问代理角色

    public class Client {
    public static void main(String[] args) {
        // 房东要租房子
        Host host = new Host();
        // 代理, 中介帮房东租房子, 但是代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        // 你不用面对房东, 直接找中介租房即可
        proxy.rent();
    }
}

代理模式的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  • 公共业务就交给了代理角色，实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理

缺点：

  • 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

10.2 加深理解

AOP：原有的开发是dao-service-controller层层嵌套纵向开发。AOP是在原有代码基础上增加一些功能实现横向开发，例如某一层添加日志功能。

10.3 动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的。
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    • 基于接口：JDK动态代理 【我们在这里使用】
    • 基于类：cglib
    • java字节码实现：JAVAssist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

动态代理的好处:

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  • 公共业务就交给了代理角色，实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可

ProxyInvocationHandler

// 等会我们会用这个类, 自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    // 被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }
    // 生成得到代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    // 处理代理实例, 并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质, 就是使用反射机制实现
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg) {
        System.out.println("执行了" + msg + "方法");
    }
}

Client

public class Client {
    public static void main(String[] args) {
        // 真实角色
        UserService userService = new UserServiceImpl();
        // 代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); // 设置要代理的对象
        // 动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

11、AOP

11.1 什么是AOP

AOP：面向切面编程，可以对业务逻辑各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

11.2 AOP在Spring中的作用

提供声明式事务：允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即与业务逻辑无关的，但是需要我们关注的部分，就是横切关注点。如日志、安全、缓存、事务等等。

切面：横切关注点被模块化的特殊对象。即，它是一个类。(Log类)

通知：切面必须要完成的工作。即，它是类中的一个方法。(Log中的方法)

目标：被通知对象。

代理：向目标对象应用通知之后创建的对象

切入点：切面通知 执行的"地点"的定义

连接点：与切入点匹配的执行点

11.3 使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

方式一: 使用Spring的API接口

UserService

public interface UserService {
    void add();
    void delete();
    void update();
    void select();
}

UserServiceImpl

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void select() {
        System.out.println("查询了一个用户");
    }
}

前置日志: Log

public class Log implements MethodBeforeAdvice {
    // method: 要执行的目标对象的方法
    // args: 参数
    // target: 目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

后置日志: AfterLog

public class AfterLog implements AfterReturningAdvice {
    // returnValue: 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法, 返回结果为:" + returnValue);
    }
}

applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 注册bean -->
    <bean id="userService" class="com.tangyixing.service.UserServiceImpl"/>
    <bean id="log" class="com.tangyixing.log.Log"/>
    <bean id="afterLog" class="com.tangyixing.log.AfterLog"/>
    <!-- 方式一: 配置aop: 需要导入aop的约束 -->
    <aop:config>
        <!-- 切入点: expression: 表达式: execution(要执行的位置) -->
        <aop:pointcut id="pointcut" expression="execution(* com.tangyixing.service.UserServiceImpl.*(..))"/>
        <!-- 执行环绕增强 -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 注意点: 动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

方式二: 自定义类来实现AOP

没有方式一强大, 方式一可以操作类中的一些方法, 方式二只是普通的类, 简单易理解

DiyPointCut

public class DiyPointCut {
    public void before() {
        System.out.println("==========方法执行前==========");
    }
    public void after() {
        System.out.println("==========方法执行后==========");
    }
}

applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 注册bean -->
    <bean id="userService" class="com.tangyixing.service.UserServiceImpl"/>
    <bean id="log" class="com.tangyixing.log.Log"/>
    <bean id="afterLog" class="com.tangyixing.log.AfterLog"/>
    <!-- 方式二: 自定义类 -->
    <bean id="diy" class="com.tangyixing.diy.DiyPointCut"/>
    <aop:config>
        <!-- 自定义切面, ref: 要引用的类 -->
        <aop:aspect ref="diy">
            <!-- 切入点 -->
            <aop:pointcut id="point" expression="execution(* com.tangyixing.service.UserServiceImpl.*(..))"/>
            <!-- 通知 -->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

方式三: 使用注解实现

AnnotationPointCut

// 方式三: 使用注解方式实现AOP
@Aspect // 标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.tangyixing.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("=====方法执行前=====");
    }
    @After("execution(* com.tangyixing.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("=====方法执行后=====");
    }
    // 在环绕增强中, 我们可以给定一个参数, 代表我们要获取处理切入的点
    @Around("execution(* com.tangyixing.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature();// 获得签名
        System.out.println("signature" + signature);
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 注册bean -->
    <bean id="userService" class="com.tangyixing.service.UserServiceImpl"/>
    <bean id="log" class="com.tangyixing.log.Log"/>
    <bean id="afterLog" class="com.tangyixing.log.AfterLog"/>
    <!-- 方式三 -->
    <bean id="annotationPointCut" class="com.tangyixing.diy.AnnotationPointCut"/>
    <aop:aspectj-autoproxy/>
</beans>

12、整合MyBatis

步骤：

  1. 导入相关jar包

    • junit
    • MyBatis
    • mysql数据库
    • spring相关的
    • aop织入
    • mybatis-spring【new】

  2. 编写配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>Spring-Study</artifactId>
        <groupId>com.tangyixing</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>spring-10-mybatis</artifactId>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
    </dependencies>
</project>

  3. 测试

12.1 回忆MyBatis

  1. 编写实体类
  2. 编写核心配置文件
  3. 编写接口
  4. 编写Mapper.xml
  5. 测试

12.2 MyBatis-Spring

  1. 编写数据源配置
  2. sqlSessionFactory
  3. sqlSessionTemplate（sqlSession）
  4. 需要给接口加实现类
  5. 将自己写的实现类注入到Spring中
  6. 测试使用

spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="245419"/>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        <property name="configLocation" value="classpath:mybatis-config.xml"/>-->
        <property name="mapperLocations" value="classpath:com/tangyixing/mapper/UserMapper.xml"/>
    </bean>
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <bean id="userMapper" class="com.tangyixing.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
</beans>

applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <import resource="spring-dao.xml"/>
</beans>

UserMapperImpl.xml

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

测试类

public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

13、声明式事务

13.1 回顾事务

  • 把一组业务当成一个业务来做，要么都成功，要么都失败
  • 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎
  • 确保完整性和一致性

事务的ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能操作同一个资源，防止数据损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中

13.2 Spring中的事务管理

  • 声明式事务：AOP
  • 编程式事务：需要在代码中，进行事务的管理

spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd">
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="245419"/>
    </bean>
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
<!--        <property name="configLocation" value="classpath:mybatis-config.xml"/>-->
        <property name="mapperLocations" value="classpath:com/tangyixing/mapper/UserMapper.xml"/>
    </bean>
<!--    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">-->
<!--        <constructor-arg index="0" ref="sqlSessionFactory"/>-->
<!--    </bean>-->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.tangyixing.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

为什么需要事务?

  • 如果不配置事务，可能存在数据提交不一致的情况
  • 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务
  • 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎
檀雨溪Ising
关注
Spring学习笔记 自我总结
11-02
spring学习笔记
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Spring 学习笔记
低吟不作语的博客
09-03 1335
Spring 是一个企业级 J2EE 应用开发一站式解决方案，其提供的功能贯穿了项目开发的表现层、业务层和持久化层，同时，Spring 可以和其他应用框架无缝整合轻量：Spring 是一个轻量级的框架，其核心 JAR 包的大小均为 1MB 左右。从系统的资源使用上来说，Spring 也是一个轻量级的框架，在其运行期间只需少量的操作系统资源便能稳定运行。
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1603
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
【Spring】Spring学习笔记完整篇
MS_SONG的博客
08-09 2470
spring学习笔记完整版
spring学习笔记
jiangYIer123的博客
11-13 533
ioc Spring学习笔记-狂神版 - 你当像鸟飞往你的山 - 博客园 (cnblogs.com)
Spring学习笔记之spring概述
yjnlovepy的博客
07-30 1317
Spring学习笔记之spring概述（没什么鸟用的文章）
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring学习笔记目录
忆亦何为的博客
11-12 906
Spring框架学习
【狂神说】Spring学习笔记（全）
li643937579的博客
11-27 4万+
Spring学习笔记1、Spring（2020-11-9）1.1 简介1.2 优点1.3 组成1.4 拓展2、IOC理论推导IOC本质3、HelloSpring 1、Spring（2020-11-9） 1.1 简介 SSH：Struct2 + Spring + Hibernate! SSM：SpringMVC + Spring + Mybatis! 官网：https://spring.io/projects/spring-framework#overview 官方下载地址：https://repo.sp
Spring 学习笔记(一)：Spring 框架简介及 IDEA 配置
qq_71946662的博客
04-24 2124
刚刚开始 Spring 框架，记录一下学到的东西和遇到的问题
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
Spring学习笔记+学习源码.zip
05-12
这份"Spring学习笔记+学习源码.zip"资源包含了深入学习Spring及其相关技术的知识点，以及实践代码，对提升Spring技能将大有裨益。 首先，我们来详细讨论Spring框架的主要组件和功能： 1. **依赖注入（Dependency ...
用于去噪幅度dMRI的Matlab工具箱.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
APP报毒全自动处理系统源码
10-09
APP报毒全自动处理系统源码
智能优化算法-引力搜索优化算法（GSA）（附源码）
10-09
引力搜索优化算法 (Gravitational Search Algorithm, GSA) 是一种基于牛顿万有引力定律的元启发式优化算法，由Rashedi等人于2009年提出。GSA通过模拟天体之间的引力作用来搜索最优解，适用于解决复杂的优化问题。 GSA的工作机制主要包括： 初始化：随机生成一组初始解，每个解代表一个“质量”。 计算引力：根据每个解的质量和距离，计算它们之间的引力。 更新位置：根据引力作用，更新每个解的位置，从而探索解空间。 更新质量：根据解的适应度值，更新每个解的质量，以便更好地指导搜索方向。 优点包括： 全局搜索能力：GSA能够有效地探索解空间的不同区域。 鲁棒性强：适用于多种优化问题，包括连续和离散优化。 易于实现：算法设计直观，易于编程实现。
基于springboot的餐饮管理系统源码+数据库（Java毕业设计）
最新发布
10-09
基于springboot的餐饮管理系统源码+数据库（Java毕业设计），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源主要针对计算机、通信、人工智能、自动化等相关专业的学生、老师或从业者下载使用，亦可作为期末课程设计、课程大作业、毕业设计等。项目整体具有较高的学习借鉴价值！基础能力强的可以在此基础上修改调整，以实现不同的功能。 基于springboot的餐饮管理系统源码+数据库（Java毕业设计），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源主要针对计算机、通信、人工智能、自动化等相关专业的学生、老师或从业者下载使用，亦可作为期末课程设计、课程大作业、毕业设计等。项目整体具有较高的学习借鉴价值！基础能力强的可以在此基础上修改调整，以实现不同的功能。 基于springboot的餐饮管理系统源码+数据库（Java毕业设计），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该
Python中的“异常的引发”：掌握编程中的“艺术”.pdf
10-09
在软件开发过程中，无论是初学者还是资深工程师，都可能遇到各种各样的问题。这些问题如果得不到妥善处理，轻则导致程序运行不稳定，重则引发系统崩溃。而“异常的引发”则是Python提供给我们的一种强有力的工具，它帮助我们在程序执行过程中主动识别并报告错误情况，从而使得我们可以及时采取措施来修复问题或者以一种更加优雅的方式告知用户。
spring 学习笔记
04-10
以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值