慕容峻才

Spring框架

Spring初识

Spring简介

Spring 是一个开源的轻量级 JavaEE（现在称为 Jakarta EE）开发框架，用于构建企业级应用程序和分布式系统。它提供了一种简化和解耦应用程序组件的方式，使开发人员能够更加专注于业务逻辑的实现，而不需要过多关心底层的技术细节。Spring 框架包含多个模块，每个模块提供不同的功能，如依赖注入、面向切面编程、事务管理、Web 开发等。

Spring核心概念

IoC（Inversion of Control）控制反转： IoC 是 Spring 的核心思想，它通过将对象的创建、组装和管理交给 Spring 容器来实现，从而减少了代码之间的耦合。开发人员只需要声明需要的组件，而不需要自己创建和管理对象。Spring 使用依赖注入（DI）来实现 IoC。
DI（Dependency Injection）依赖注入：依赖注入是 IoC 的具体实现，通过注入组件之间的依赖关系，实现了对象之间的解耦。Spring 通过注解或配置文件来声明依赖关系，然后将需要的依赖自动注入到对象中。
AOP（Aspect-Oriented Programming）面向切面编程： AOP 是一种编程范式，它允许开发人员将横切关注点（如日志记录、事务管理）从业务逻辑中分离出来，以便更好地维护和管理。Spring AOP 提供了切面的实现，使得开发人员能够在方法执行前、执行后或抛出异常时插入额外的逻辑。
Spring MVC： Spring MVC 是 Spring 框架的一个模块，用于构建 Web 应用程序。它提供了 MVC（Model-View-Controller）的架构，使开发人员能够将应用程序的不同方面进行分离，从而更好地管理和扩展。
Spring Boot： Spring Boot 是 Spring 生态系统中的一个子项目，旨在简化 Spring 应用程序的构建和部署。它提供了自动化配置、快速开发和微服务的支持，让开发人员能够更加轻松地创建独立的、可执行的 Spring 应用程序。
Spring Data： Spring Data 提供了一种统一的方式来访问和操作各种不同类型的数据源，如关系型数据库、NoSQL 数据库、搜索引擎等。它简化了数据访问层的开发，并提供了常见的 CRUD 操作以及查询的支持。
Spring Security： Spring Security 是 Spring 框架的安全性模块，用于实现身份验证、授权、安全配置等功能，保护应用程序免受各种安全威胁。
Spring Cloud： Spring Cloud 是用于构建分布式系统和微服务架构的一组工具和框架。它提供了服务注册与发现、负载均衡、断路器、配置管理等功能，帮助开发人员构建可靠的、可扩展的分布式应用。
Spring Integration： Spring Integration 提供了一种将不同系统和应用程序集成到一起的方式，支持消息传递、异步通信、数据转换等。

搭建Spring框架工程

新建maven项目
导入spring context jar包

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.13.2version>
        <scope>testscope>
    dependency>
dependencies>

创建bean对象

package com.acaiblog.spring.pojo;

public class User {
    private Integer id;
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

创建配置文件applicationContext.xml


<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="user" class="com.acaiblog.spring.pojo.User">
        <property name="id" value="1"/>
        <property name="name" value="acai"/>
    bean>
beans>

测试Spring

import com.acaiblog.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        // 创建容器对象
        ApplicationContext aplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取配置bean
        User user = aplicationContext.getBean("user", User.class);
        System.out.println(user);
    }
}

测试结果

User{id=1, name='acai'}

Spring特性

非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的APi
容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期
组件化：Spring实现了简单的组件化配置组合成一个复杂的应用，在Spring中可以使用XML和JAVA注解组合这些对象
一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库

Spring获取bean的三种方式

getBean(String beanId):通过beanId获取对象；缺点：需要强制类型转换，不灵活。
getBean(Class clazz):通过Class对象获取对象；缺点：容器中有多个bean会报错
getBean(String beanId,Class clazz):通过beanId和Class对象

Bean标签

在Spring Framework中，“bean” 是一个核心概念，用于定义应用程序中的各种组件、对象或服务。Spring的IoC（Inversion of Control，控制反转）容器负责管理和实例化这些bean。在XML配置文件中，使用标签来定义和配置这些bean。

Bean标签属性

属性	描述
id	表示bean的唯一标识符，应该在整个Spring上下文中是唯一的。
class	指定bean的全限定类名，用于告诉Spring容器应该实例化哪个类来创建bean对象。
scope	定义bean的作用域，常用的有singleton（单例，默认）、prototype（原型）、request、session等。例如：`scope="singleton"`。
init-method	指定在bean初始化之后调用的方法。
destroy-method	指定在bean销毁之前调用的方法。

Bean子标签property属性

property主要是用来给类对象方法注入参数

属性	描述
name	指定bean的属性名。
value	设置基本数据类型的属性值。
ref	引用其他bean作为属性值。

Bean子标签constructor-arg属性

constructor-arg标签主要是用来给构造器注入参数

属性名称	描述
index	构造函数参数的索引（从0开始）。
type	参数的数据类型。
value	参数的值，可以是字符串、基本类型或引用。
ref	参数的引用，指向另一个bean的id。
name	参数的名称，用于指定构造函数的参数名。

SpringIOC底层实现

BeanFactory与ApplicationContext

BeanFactory：IOC容器的基本实现，是Spring内部的接口。
ApplicationContext：是BeanFactory的子接口，提供更多高级的特性。面向Spring使用者，几乎所有场合都使用ApplicationContext而不是BeanFactory

Spring数值的注入方式

set方法
通过构造器
名称空间注入

set注入

语法

<bean id="user" class="com.acaiblog.spring.pojo.User">
    <property name="id" value="1"/>
    <property name="name" value="acai"/>
bean>

构造器注入

<bean id="user" class="com.acaiblog.spring.pojo.User">
    <constructor-arg name="id" value="2"/>
    <constructor-arg name="name" value="acai"/>
bean>

名称空间注入

<bean id="user"
      class="com.acaiblog.spring.pojo.User"
      p:id="1"
      p:name="acaiblog">
bean>

外部已声明bean

如果想通过查询员工信息的同时获取员工所在部门信息就需要使用外部已声明bean

员工bean

package com.acaiblog.spring.pojo;

public class Employee {
    private Integer id;
    private String name;
    private String email;
    private Dept dept;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", dept=" + dept +
                '}';
    }
}

部门bean

package com.acaiblog.spring.pojo;

public class Dept {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dept{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

Spring配置文件

<bean id="dept1" class="com.acaiblog.spring.pojo.Dept">
    <property name="id" value="1"/>
    <property name="name" value="运维部"/>
bean>
<bean id="employee" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="1"/>
    <property name="name" value="acai"/>
    <property name="email" value="[email protected]"/>
    <property name="dept" ref="dept1"/>
bean>

测试代码

import com.acaiblog.spring.pojo.Employee;
import com.acaiblog.spring.pojo.User;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        // 创建容器对象
        ApplicationContext aplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取配置bean
        Employee employee = aplicationContext.getBean("employee", Employee.class);
        System.out.println(employee);

    }
}

测试结果

Employee{id=1, name='acai', email='[email protected]', dept=Dept{id=1, name='运维部'}}

bean级联属性赋值

<bean id="dept1" class="com.acaiblog.spring.pojo.Dept">
    <property name="id" value="1"/>
    <property name="name" value="运维部"/>
bean>
<bean id="employee" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="1"/>
    <property name="name" value="acai"/>
    <property name="email" value="[email protected]"/>
    <property name="dept" ref="dept1"/>
    
    <property name="dept.name" value="测试部"/>
bean>

内部bean属性赋值

内部bean不会覆盖外部bean的属性值

<bean id="employee" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="1"/>
    <property name="name" value="acai"/>
    <property name="email" value="[email protected]"/>
    <property name="dept">
        <bean class="com.acaiblog.spring.pojo.Dept">
            <property name="id" value="2"/>
            <property name="name" value="研发部"/>
        bean>
    property>
bean>

bean List集合注入赋值

需求

比如云计算事业部，有两个员工。使用List集合的方式展示数据

在Dept pojo中新增employeeList类属性，并且新增get、set、tostring方法

public class Dept {
    private List<Employee> employeeList;
    public List<Employee> getEmployeeList() {
        return employeeList;
    }

    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }
    @Override
    public String toString() {
        return "Dept{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", employeeList=" + employeeList +
                '}';
    }
}

编辑bean

<bean id="zhangsan" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="1"/>
    <property name="name" value="zhangsan"/>
    <property name="email" value="[email protected]"/>
bean>
<bean id="lisi" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="2"/>
    <property name="name" value="lisi"/>
    <property name="email" value="[email protected]"/>
bean>

<bean id="dept" class="com.acaiblog.spring.pojo.Dept">
    <property name="id" value="1"/>
    <property name="name" value="云计算事业部"/>
    <property name="employeeList">
        <list>
            <ref bean="zhangsan"/>
            <ref bean="lisi"/>
        list>
    property>
bean>

测试代码

public class TestSpring {
    @Test
    public void test(){
        // 创建容器对象
        ApplicationContext aplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取配置bean
        Dept dept = aplicationContext.getBean("dept", Dept.class);
        System.out.println(dept);

    }
}

测试结果

Dept{id=1, name='云计算事业部', employeeList=[Employee{id=1, name='zhangsan', email='[email protected]', dept=null, empList=null}, Employee{id=2, name='lisi', email='[email protected]', dept=null, empList=null}]}

bean Map集合注入赋值

在Dept pojo类新增map属性

public class Dept {
    private Map<String, Employee> employeeMap;
    public Map<String, Employee> getEmployeeMap() {
        return employeeMap;
    }

    public void setEmployeeMap(Map<String, Employee> employeeMap) {
        this.employeeMap = employeeMap;
    }
    @Override
    public String toString() {
        return "Dept{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", employeeList=" + employeeList +
                ", employeeMap=" + employeeMap +
                '}';
    }
}

编辑Spring bean配置文件

<bean id="zhangsan" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="1"/>
    <property name="name" value="zhangsan"/>
    <property name="email" value="[email protected]"/>
bean>
<bean id="lisi" class="com.acaiblog.spring.pojo.Employee">
    <property name="id" value="2"/>
    <property name="name" value="lisi"/>
    <property name="email" value="[email protected]"/>
bean>

<bean id="dept" class="com.acaiblog.spring.pojo.Dept">
    <property name="id" value="1"/>
    <property name="name" value="云计算事业部"/>
    <property name="employeeMap">
        <map>
            <entry>
                <key><value>111value>key>
                <ref bean="zhangsan"/>
            entry>
            <entry>
                <key><value>222value>key>
                <ref bean="lisi"/>
            entry>

        map>
    property>
bean>

测试代码

public class TestSpring {
    @Test
    public void test(){
        // 创建容器对象
        ApplicationContext aplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取配置bean
        Dept dept = aplicationContext.getBean("dept", Dept.class);
        System.out.println(dept);

    }
}

测试结果

Dept{id=1, name='云计算事业部', employeeList=null, employeeMap={111=Employee{id=1, name='zhangsan', email='[email protected]', dept=null, empList=null}, 222=Employee{id=2, name='lisi', email='[email protected]', dept=null, empList=null}}}

Spring管理第三方bean

Spring管理druid

导入jar依赖包

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.2.18version>
dependency>
<dependency>
    <groupId>org.mariadb.jdbcgroupId>
    <artifactId>mariadb-java-clientartifactId>
    <version>3.1.4version>
dependency>

编写数据库配置文件

#db.properties
db.driver=org.mariadb.jdbc.Driver
db.url=jdbc:mariadb://acaiblog.top:3306/spring
db.username=root
db.password=123456

在beans配置文件中加载数据库配置文件

<context:property-placeholder location="classpath:db.properties">context:property-placeholder>

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${db.driver}"/>
    <property name="url" value="${db.url}"/>
    <property name="username" value="${db.username}"/>
    <property name="password" value="${db.password}"/>
bean>

测试代码

public class TestSpring {
    @Test
    public void test() throws Exception{
        // 创建容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取bean
        DruidDataSource druidDataSource = applicationContext.getBean("dataSource", DruidDataSource.class);
        // 连接数据库对象
        DruidPooledConnection druidPooledConnection = druidDataSource.getConnection();
        System.out.println(druidPooledConnection);
    }
}

Spring FactoryBean

FactoryBean 是 Spring 框架中的一个接口，用于创建和管理 Spring 容器中的对象。它允许开发人员在创建 bean 实例时进行更加灵活和自定义的操作。通过实现 FactoryBean 接口，您可以控制 bean 的实例化、初始化和销毁过程，以及对外暴露的对象类型。

内置方法

方法	描述
`getObject()`	实际创建和返回 bean 实例，可以执行自定义逻辑，如从外部资源加载数据、实例化其他对象等。
`getObjectType()`	返回由 `FactoryBean` 创建的对象的类型，通常用于告诉 Spring 容器实际创建的 bean 类型。
`isSingleton()`	返回一个布尔值，指示由 `FactoryBean` 创建的对象是否是单例（singleton）或原型（prototype）。

实现步骤

重写FactoryBean方法

package com.acaiblog.spring.Factory;
import com.acaiblog.spring.pojo.Dept;
import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean<Dept> {
    @Override
    public boolean isSingleton() {
        /**设置参数是否为单例*/
        return FactoryBean.super.isSingleton();
    }

    @Override
    public Dept getObject() throws Exception {
        /**参数对象创建的方法，比如：创建一个部门然后将部门返回*/
        Dept dept = new Dept(1,"运维部");
        return dept;
    }

    @Override
    public Class<?> getObjectType() {
        /**设置参数对象class*/
        return Dept.class;
    }
}

装配Bean

<bean id="factoryBean" class="com.acaiblog.spring.Factory.MyFactoryBean">

测试代码

public class TestSpring {
    @Test
    public void test() throws Exception{
        // 创建容器对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取bean
        Dept dept = applicationContext.getBean("factoryBean", Dept.class);
        System.out.println(dept);
    }
}

测试结果

Dept{id=1, name='运维部', employeeList=null, employeeMap=null}

Spring Bean的作用域

语法

在 Spring 配置文件中使用标签的 scope 属性来显式指定 Bean 的作用域。例如：

<bean id="myBean" class="com.example.MyBean" scope="prototype"/>

作用域

作用域	描述
singleton	每个 Spring 容器中只会存在一个单例的 Bean 实例。在应用程序生命周期内，只会创建一个 Bean 实例并缓存以供后续使用。
prototype	每次请求该 Bean 时，都会创建一个新的实例。不同地方请求该 Bean 会得到不同的实例。
request	在 Web 应用中有效，每个 HTTP 请求都会创建一个新的 Bean 实例，在整个请求周期内有效。不同请求间可对应不同的实例。
session	在 Web 应用中有效，每个用户会话（Session）都会创建一个新的 Bean 实例，在整个会话周期内有效。不同用户对应不同的实例。
application	在 Web 应用中有效，每个 ServletContext（Web 应用上下文）都会创建一个新的 Bean 实例，在整个应用生命周期内有效。
websocket	在 Web 应用中有效，每个 WebSocket 会话都会创建一个新的 Bean 实例，在整个 WebSocket 会话周期内有效。
custom	您可以实现自定义的作用域，通过实现 org.springframework.beans.factory.config.Scope 接口来定义更灵活的作用域。

Spring Bean生命周期

在Spring框架中，Bean的生命周期是指一个Bean从被创建到被销毁的整个过程。Spring框架提供了丰富的生命周期回调方法，可以让开发者在不同的阶段进行自定义操作。

BeanFactory接口描述

接口名称	特点
ConfigurableApplicationContext	可配置和修改应用程序上下文，包含刷新和关闭方法。
ApplicationContext	提供核心功能的只读应用程序上下文，无法在运行时修改或重新配置。

生命周期步骤

创建Student类

package com.acaiblog.spring.pojo;

public class Student {
    private Integer id;
    private String name;

    public void Init(){
        System.out.println("初始化方法");
    }
    public void Destory(){
        System.out.println("销毁方法");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

设置Bean属性值，init-method在示例创建之前调用初始化的方法；destroy-method容器关闭之后调用销毁方法

<bean id="student" class="com.acaiblog.spring.pojo.Student" init-method="Init" destroy-method="Destory">
    <property name="id" value="1"/>
    <property name="name" value="慕容峻才"/>
bean>

测试代码

public class TestSpring {
    @Test
    public void test() throws Exception{
        // 创建容器对象使用ConfigurableApplicationContext可以关闭容器，用来自动调用销毁方法
        ConfigurableApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取bean
        Student student = applicationContext.getBean("student", Student.class);
        System.out.println(student);
        // 调用Bean中定义的destroy-method方法
        applicationContext.close();
    }
}

测试结果

初始化方法
Student{id=1, name='慕容峻才'}
销毁方法

Bean的后置处理器

作用

在初始化前后对bean进行额外的处理

实现步骤

实现BeanPostProcessor接口

package com.acaiblog.spring.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * Bean初始化之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean初始化之前执行");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    /**
     * Bean初始化之后会执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Bean初始化之后执行");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

Bean配置文件装配后置处理器

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

    <bean id="student" class="com.acaiblog.spring.pojo.Student" init-method="Init" destroy-method="Destory">
        <property name="id" value="1"/>
        <property name="name" value="慕容峻才"/>
    bean>
    <bean class="com.acaiblog.spring.processor.MyBeanPostProcessor"/>
beans>

Spring基于xml自动装配

根据bean标签的autowire属性指定装配规则，不需要明确指定。Spring自动将匹配的属性值注入bean中。autowire属性值如下表：

属性名	描述
byName	按组件名称自动装配
byType	按组件类型自动装配
constructor	通过构造函数自动装配

环境搭建

创建部门接口

package com.acaiblog.spring.dao;

import com.acaiblog.spring.pojo.Dept;

public interface DeptDao {
    /**
     * 添加部门信息
     * @param dept
     */
    public void insertDept(Dept dept);
}

创建部门的实现类

package com.acaiblog.spring.dao.Impl;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;

public class DeptDaoImpl  implements DeptDao {
    @Override
    public void insertDept(Dept dept) {
        System.out.println("添加部门成功");
    }
}

创建部门的service

package com.acaiblog.spring.service;

import com.acaiblog.spring.pojo.Dept;

public interface DeptService {
    /**
     * 添加部门信息
     * @param dept
     */
    public void save(Dept dept);
}

创建部门service的实现类

package com.acaiblog.spring.service.Impl;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;

public class DeptServiceImpl implements DeptService {
    private DeptDao deptDao;
    @Override
    public void save(Dept dept) {
        deptDao.insertDept(dept);
    }
}

测试代码

public class TestSpring {
    @Test
    public void test() throws Exception{
        // 创建容器对象使用ConfigurableApplicationContext可以关闭容器，用来自动调用销毁方法
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        // 获取bean
        DeptService deptService = applicationContext.getBean("deptService", DeptService.class);
        deptService.saveDept(new Dept());
    }
}

byName自动装配

对象中属性与容器中的beanId进行匹配，如果属性名和beanId匹配成功则自动装配成功

<bean id="deptDao" class="com.acaiblog.spring.dao.Impl.DeptDaoImpl">bean>
<bean id="deptService" class="com.acaiblog.spring.service.Impl.DeptServiceImpl" autowire="byName">bean>

byType自动装配

对象中的属性类型与容器中bean的class进行匹配，如果唯一匹配则自动装配成功

<bean id="deptDao" class="com.acaiblog.spring.dao.Impl.DeptDaoImpl">bean>
<bean id="deptService" class="com.acaiblog.spring.service.Impl.DeptServiceImpl" autowire="byType">bean>

总结

基于xml的自动装配，底层使用set注入
不建议使用byName、byType，建议实现注解的方式实现自动装配

Spring中的注解

搭建环境

创建spring工程day07_spring导入spring相关依赖包

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.13.2version>
        <scope>testscope>
    dependency>
dependencies>

创建Employee pojo

package com.acaiblog.spring.pojo;

import java.util.List;

public class Employee {
    private Integer id;
    private String name;
    private String email;
    private Dept dept;

    private List<Employee> empList;

    public List<Employee> getEmpList() {
        return empList;
    }

    public void setEmpList(List<Employee> empList) {
        this.empList = empList;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", dept=" + dept +
                ", empList=" + empList +
                '}';
    }
}

创建dept pojo

package com.acaiblog.spring.pojo;

import java.util.List;
import java.util.Map;

public class Dept {
    private Integer id;
    private String name;
    private List<Employee> employeeList;
    private Map<String, Employee> employeeMap;


    @Override
    public String toString() {
        return "Dept{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", employeeList=" + employeeList +
                ", employeeMap=" + employeeMap +
                '}';
    }

    public Map<String, Employee> getEmployeeMap() {
        return employeeMap;
    }

    public void setEmployeeMap(Map<String, Employee> employeeMap) {
        this.employeeMap = employeeMap;
    }

    public List<Employee> getEmployeeList() {
        return employeeList;
    }

    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

}

创建Dept接口

package com.acaiblog.spring.dao;

import com.acaiblog.spring.pojo.Dept;

public interface DeptDao {
    /*
    * 新增部门信息*/
    public void insertDept(Dept dept);
}

创建DeptDaoImpl

package com.acaiblog.spring.dao.impI;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;

public class DeptDaoImpl implements DeptDao {

    @Override
    public void insertDept(Dept dept) {
        System.out.println("添加部门成功");
    }
}

创建DeptService

package com.acaiblog.spring.service;

import com.acaiblog.spring.pojo.Dept;

public interface DeptService {
    /*
    * 添加部门*/
    public void saveDept(Dept dept);
}

创建DeptServiceImpl

package com.acaiblog.spring.service.impl;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;

public class DeptServiceImpl implements DeptService {
    private DeptDao deptDao;
    @Override
    public void saveDept(Dept dept) {
        deptDao.insertDept(dept);
    }
}

创建DeptController

package com.acaiblog.spring.controller;

import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;

public class DeptController {
    private DeptService deptService;
    public void saveDept(){
        deptService.saveDept(new Dept());
    }
}

创建spring配置文件


<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="deptDao" class="com.acaiblog.spring.dao.impI.DeptDaoImpl">bean>
beans>

创建测试代码,验证环境没有问题

import com.acaiblog.spring.dao.impI.DeptDaoImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        DeptDaoImpl deptDao = context.getBean("deptDao", DeptDaoImpl.class);
        System.out.println("deptDao:" + deptDao);
    }
}

使用注解将对象装配到IOC容器中

注解的位置: 在类的上面标识
使用注解装配：默认将类名首字母小写作为bean id；可以使用value属性为类的bean id指定id；当注解中只使用一个value属性时，value关键字可以省略
使用注解的步骤：导入相关jar包，spring默认已经导入；开启组件扫描；使用注解标识组件

注解	描述
`@Autowired`	自动装配依赖关系。
`@Component`	通用的Spring组件注解。
`@Controller`	标识控制器类。
`@Service`	标识服务类。
`@Repository`	标识数据访问对象（DAO）类。

注解实现步骤

DeptDaoImpl中定义注解

package com.acaiblog.spring.dao.impI;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;
import org.springframework.stereotype.Repository;

@Repository("deptDao")
public class DeptDaoImpl implements DeptDao {

    @Override
    public void insertDept(Dept dept) {
        System.out.println("添加部门成功");
    }
}

pojo中定义注解

package com.acaiblog.spring.pojo;

import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
@Component
public class Dept {
}

service中定义注解

package com.acaiblog.spring.service.impl;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;
import org.springframework.stereotype.Service;

@Service
public class DeptServiceImpl implements DeptService {
    private DeptDao deptDao;
    @Override
    public void saveDept(Dept dept) {
        deptDao.insertDept(dept);
    }
}

controller中定义注解

package com.acaiblog.spring.controller;

import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;
import org.springframework.stereotype.Controller;

@Controller
public class DeptController {
    private DeptService deptService;
    public void saveDept(){
        deptService.saveDept(new Dept());
    }
}

spring配置文件设置扫描注解


<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 http://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.acaiblog.spring">context:component-scan>
beans>

测试代码

import com.acaiblog.spring.controller.DeptController;
import com.acaiblog.spring.dao.impI.DeptDaoImpl;
import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.impl.DeptServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        Dept dept = context.getBean("dept", Dept.class);
        DeptDaoImpl deptDao = context.getBean("deptDao", DeptDaoImpl.class);
        DeptServiceImpl deptService = context.getBean("deptServiceImpl", DeptServiceImpl.class);
        DeptController deptController = context.getBean("deptController", DeptController.class);
        System.out.println("dept:" + dept);
        System.out.println("deptDao:" + deptDao);
        System.out.println("deptService:" + deptService);
        System.out.println("deptController:" + deptController);
    }
}

使用注解装配对象中的属性`[自动装配]`

@Autowired

@Autowired注解作用：自动装配对象中的属性
@Autowired注解装配原理：反射机制
@Autowired注解装配方式：先byType匹配，如果匹配0个返回错误；如果匹配1个正常允许；如果匹配多个再按照byName进行唯一筛选匹配，筛选成功对象中的属性名称等同于beanId，筛选是吧对象中的属性名称比等于beanId。
@Autowired注解required属性为true，表示被标识的属性必须装配数值，如未装配会报错；属性为false，表示被标识的属性必须装配属性，如未装配不会报错。

实现步骤

添加注解

package com.acaiblog.spring.service.impl;

import com.acaiblog.spring.dao.DeptDao;
import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptDao deptDao;
    @Override
    public void saveDept(Dept dept) {
        deptDao.insertDept(dept);
    }
}

测试代码

import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;
import com.acaiblog.spring.service.impl.DeptServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        DeptService deptService = context.getBean("deptServiceImpl", DeptServiceImpl.class);
        deptService.saveDept(new Dept());
    }
}

测试结果

添加部门成功

@Qualifier

@Qualifier和@Autowired配合使用，将设置的beanId名称装配到对象属性中。

Spring组件扫描

扫描包下所有子包

<context:component-scan base-package="com.acaiblog.spring">context:component-scan>

扫描指定的多个包

<context:component-scan base-package="com.acaiblog.aaa,com.acaiblog.bbb">context:component-scan>

包含扫描


<context:component-scan base-package="com.acaiblog.spring" use-default-filters="false">
    
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    
    <context:include-filter type="assignable" expression="com.acaiblog.spring.service.impl.DeptServiceImpl"/>
context:component-scan>

排除扫描

<context:component-scan base-package="com.acaiblog.spring">

    <context:exclude-filter type="assignable" expression="org.springframework.stereotype.Controller"/>
context:component-scan>

Spring完全注解开发

@Configuration 将该注解的类代替xml配置文件
@ComponentSan 配置要扫描的包

实现步骤

创建配置类,在类上面添加注解

package com.acaiblog.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.acaiblog.spring")
public class SpringConfig {
}

使用AnnotationConfigApplicationContext容器对象

import com.acaiblog.spring.config.SpringConfig;
import com.acaiblog.spring.pojo.Dept;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {
    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        Dept dept = context.getBean("dept", Dept.class);
        System.out.println("dept: "+ dept);
    }
}

测试结果

dept: Dept{id=null, name='null', employeeList=null, employeeMap=null}

Spring集成Junit4

导入jar包

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>5.3.10version>
    <scope>testscope>
dependency>

指定Spring配置文件路径和Spring环境下运行Junit4的运行器

import com.acaiblog.spring.pojo.Dept;
import com.acaiblog.spring.service.DeptService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(locations = "classpath:application.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunit4Test {
    @Autowired
    private DeptService deptService;
    @Test
    public void test(){
        deptService.saveDept(new Dept());
    }
}

Spring AOP

AOP概述

AOP：Aspect-Oriented Programming，面向切面编程；是对OOP(Object-Oriented Programming，面向对象编程)的一种扩展，是一种通过动态代理实现程序功能扩展和统一维护的技术。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提供程序的可重用行，同时提高了开发的效率。

AOP专业术语

横切关注点：非核心代码，称之为横切关注点
切面：将横切关注点提取到类，称之为切面类
通知：将横切关注点提取到类之后，横切关注点更名为通知
目标：目标对象，指的是需要被代理的对象(实现类)
代理：代理对象可以理解为中转
连接点：通知方法需要指定通知位置，这个位置称之为连接点(通知之前)
切入点：通知方法需要指定通知位置，这个位置称之为连接点(通知之后)

AspectJ框架

AspectJ是java社区里最完整的AOP框架，在Spring2.0以上版本中可以使用基于AspectJ注解或基于xml配置的AOP。

切入点表达式

语法

@Before(value = "execution(权限修饰符 返回值类型 包名.类名.方法(参数类型))")

通配符

通配符	描述
`*`	可以代表任意权限修饰符和返回值类型，可以代表任意包名、类名、方法名
`..`	代表任意参数类型及参数个数

重用切入点表达式

使用@PointCut注解，提取可重用的切入点表达式

@PointCut("execution(* com.acaiblog.aop.CalcImpl.*(..))")
public vold MyPoint(){}

使用方法名引入切入点表达式：

@Before(value = "MyPoint()")
public vold BeforeMethod(JoinPoint joinPoint){}

JoinPoint对象

作用

获取方法名称：joinPoint.getSignature().getName();
获取参数名称：joinPoint.getArgs();

AspectJ 通知

前置通知

语法：@Before
执行时机：指定方法执行之前执行，指定方法是切入点表达式设置位置

后置通知

语法：@After
执行时机：指定方法执行之后执行

返回通知

语法：@AfterReturning
执行时机：指定方法返回结果时执行
注意事项：@AfterReturning中的returning属性与方法入参参数名一致

异常通知

语法：@AfterThrowing
执行时机：指定方法出现异常时执行

环绕通知

语法：@Around
作用：整合前面4个通知
注意：参数中必须使用ProceedingJoinPoint

定义切面的优先级

语法：@Oder(value=index)，index是int类型，默认值是int可存储的最大值；数值越小优先级越高

使用AspectJ框架

pom.xml添加jar包

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.13.2version>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.3.10version>
        <scope>testscope>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-aspectsartifactId>
        <version>5.3.10version>
    dependency>
dependencies>

编写applicationContext.xml配置文件


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

        <context:component-scan base-package="com.acaiblog.aop">context:component-scan>

        <aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>

在MyLogging中配置切面类

package com.acaiblog.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;
@Component
@Aspect
public class MyLogging {
    @Before(value = "execution(public int add(int,int))")
    public static void beforeMethod(JoinPoint joinPoint){
//        获取方法名称
        String methodName = joinPoint.getSignature().getName();
//        获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("Calc:" + methodName + "方法,参数:" + Arrays.toString(args));
    }
    public static void afterMethod(String methodName, Object[] args){
        System.out.println("Calc:" + methodName + "方法,参数:" + Arrays.toString(args));
    }
}

JDBCTemplate

什么是JDBCTemplate

JDBCTemplate是一个Spring提供的小型持久化框架，简化jdbc的代码。

基本使用

pom.xml导入jar包

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-ormartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>org.mariadb.jdbcgroupId>
        <artifactId>mariadb-java-clientartifactId>
        <version>3.1.4version>
    dependency>
    <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druidartifactId>
        <version>1.2.19version>
    dependency>
dependencies>

resource下创建db配置文件db.properties

db.driver=org.mariadb.jdbc.Driver
db.url=jdbc:mariadb://127.0.0.1:3306/jdbc
db.username=root
db.password=123

resource下创建spring配置文件application.xml


<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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:property-placeholder location="classpath:db.properties">context:property-placeholder>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    bean>
beans>

编写测试类

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        System.out.println(jdbcTemplate);
    }
}

JDBCTemplate常用API

增加

方法	描述
`update(String sql)`	执行给定的 SQL 更新语句，返回受影响的行数。
`update(String sql, Object... args)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`update(String sql, SqlParameterSource paramSource)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`batchUpdate(String sql, BatchPreparedStatementSetter pss)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。
`batchUpdate(String sql, Map[] batchValues)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。

删除

方法	描述
`update(String sql)`	执行给定的 SQL 更新语句，返回受影响的行数。
`update(String sql, Object... args)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`update(String sql, SqlParameterSource paramSource)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`batchUpdate(String sql, BatchPreparedStatementSetter pss)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。
`batchUpdate(String sql, Map[] batchValues)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。

修改

方法	描述
`update(String sql)`	执行给定的 SQL 更新语句，返回受影响的行数。
`update(String sql, Object... args)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`update(String sql, SqlParameterSource paramSource)`	执行带参数的 SQL 更新语句，返回受影响的行数。
`batchUpdate(String sql, BatchPreparedStatementSetter pss)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。
`batchUpdate(String sql, Map[] batchValues)`	批量执行带参数的 SQL 更新语句，每个更新语句在事务中执行。

查询

方法	描述
`query(String sql, RowMapper rowMapper)`	执行给定的 SQL 查询语句，将结果映射为对象列表。
`queryForObject(String sql, Class elementType)`	执行给定的 SQL 查询语句，返回单个结果对象。
`queryForList(String sql)`	执行给定的 SQL 查询语句，返回结果列表。
`queryForMap(String sql)`	执行给定的 SQL 查询语句，将结果映射为键值对。
`queryForList(String sql, Class elementType)`	执行给定的 SQL 查询语句，将结果映射为指定类型的对象列表。
`queryForMap(String sql, Object... args)`	执行带参数的 SQL 查询语句，将结果映射为键值对。
`queryForObject(String sql, Class elementType, Object... args)`	执行带参数的 SQL 查询语句，返回单个结果对象。
`queryForList(String sql, Object... args)`	执行带参数的 SQL 查询语句，返回结果列表。
`query(String sql, RowMapper rowMapper, Object... args)`	执行带参数的 SQL 查询语句，将结果映射为对象列表。
`queryForMap(String sql, SqlParameterSource paramSource)`	执行带参数的 SQL 查询语句，将结果映射为键值对。
`queryForObject(String sql, SqlParameterSource paramSource, Class elementType)`	执行带参数的 SQL 查询语句，返回单个结果对象。
`queryForList(String sql, SqlParameterSource paramSource)`	执行带参数的 SQL 查询语句，返回结果列表。
`query(String sql, RowMapper rowMapper, SqlParameterSource paramSource)`	执行带参数的 SQL 查询语句，将结果映射为对象列表。

设计数据库表结构

create table dept(
    id int auto_increment
        primary key,
    name varchar(255) not null
);

增加数据

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        System.out.println("test");
        String sql = "insert into dept(name) values(?)";
//        jdbcTemplate自动提交事务
        jdbcTemplate.update(sql,"人事部");
    }
}

修改数据

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        String sql = "update dept set name=? where id=?";
//        jdbcTemplate自动提交事务
        jdbcTemplate.update(sql,"运维部",3);
    }
}

删除数据

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        String sql = "delete from dept where id = ?";
        jdbcTemplate.update(sql,2);
    }
}

批量增加

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        List<Object[]> deptList = new ArrayList<>();
        deptList.add(new Object[]{"测试部"});
        deptList.add(new Object[]{"运维部"});
        deptList.add(new Object[]{"测试部"});
        String sql = "insert into dept(name) values(?)";
        jdbcTemplate.batchUpdate(sql,deptList);
    }
}

查询

查询单个数值

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        String sql = "select count(1) from dept";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.printf("员工数量: %d%n", count);
    }
}

查询单个对象

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import com.acaiblog.jdbc.pojo.Dept;
import org.springframework.jdbc.core.RowMapper;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        String sql = "select name from dept where id = ?";
        RowMapper<Dept> rowMapper = new BeanPropertyRowMapper<>(Dept.class);
        Dept dept = jdbcTemplate.queryForObject(sql, rowMapper, 3);
        System.out.printf("dept: %s", dept);
    }
}

查询多个对象

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import com.acaiblog.jdbc.pojo.Dept;
import org.springframework.jdbc.core.RowMapper;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TestSpringJDBCTemplate {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
        String sql = "select name from dept";
        RowMapper<Dept> rowMapper = new BeanPropertyRowMapper<>(Dept.class);
        List<Dept> dept = jdbcTemplate.query(sql, rowMapper);
        System.out.printf("dept: %s", dept);
    }
}

Spring声明式事务管理

编程式事务管理

获取数据库连接Connection对象
取消事务的自动提交
执行操作
正常完成操作时手动提交事务
执行失败时回滚事务
关闭相关资源

声明式事务管理【AOP管理事务】

先横向提取事务管理代码，再动态置入

使用声明式事务管理

创建数据库表

create table book(
    isbn varchar(50) primary key,
    book_name varchar(100),
    price int
);
create table book_stock(
    isbn varchar(50) primary key,
    stock int
);
create table account(
    id int primary key,
    username varchar(50),
    balance int
);

pom.xml中添加依赖包

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-ormartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-aspectsartifactId>
        <version>5.3.10version>
    dependency>
    <dependency>
        <groupId>org.mariadb.jdbcgroupId>
        <artifactId>mariadb-java-clientartifactId>
        <version>3.1.4version>
    dependency>
    <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druidartifactId>
        <version>1.2.19version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.13.2version>
        <scope>testscope>
    dependency>
dependencies>

resources下创建db.properties配置文件

db.driver=org.mariadb.jdbc.Driver
db.url= jdbc:mariadb://localhost:3306/jdbc
db.username=root
db.password=123456

resources下创建spring配置文件


<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" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    <context:component-scan base-package="com.acaiblog.spring"/>
    
    <context:property-placeholder location="classpath:db.properties"/>
    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    bean>
    
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    bean>
    
    <tx:annotation-driven>tx:annotation-driven>
beans>

创建图书接口

package com.acaiblog.spring.dao;

public interface BookShopDao {
//    根据图书编号查询图书价格
    public Integer findBookPriceByIsbn(String isbn);
//    根据图书编号修改图书库存
    public void updateBookStock(String isbn);
//    根据图书价格修改用户余额
    public void updateUserAccount(String username, Integer price);
}

创建图书接口扩展

package com.acaiblog.spring.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao{
    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    /**
     * 根据图书编号查询图书价格
     * @param isbn
     * @return
     */
    @Override
    public Integer findBookPriceByIsbn(String isbn){
        String sql = "select price from book where isbn = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class,isbn);
    }

    /**
     * 根据图书编号修改图书库存，每次只能购买一本图书，如果图书库存小于0返回异常
     * @param isbn
     */
    @Override
    public void updateBookStock(String isbn) {
//        修改库存
        String sql = "update book_stock set stock=stock-1 where isbn = ?";
        jdbcTemplate.update(sql);
//        验证库存
        String sql2 = "select stock from book_stock where isbn = ?";
        Integer newStock = jdbcTemplate.queryForObject(sql2, Integer.class,isbn);
        if(newStock <=0){
            throw new RuntimeException("库存不足");
        }
    }

    /**
     * 根据图书价格修改用户余额，如果余额不足抛出异常
     * @param username
     * @param price
     */
    @Override
    public void updateUserAccount(String username, Integer price) {
//        查询余额是否充足
        String sql = "select balance from account where username = ?";
        Integer balance = jdbcTemplate.queryForObject(sql, Integer.class, username);
        if(balance < price){
            throw new RuntimeException("账户余额小于图书价格");
        }
//        修改用户余额
        String sql1 = "update account set balance = balance-? where username = ?";
        jdbcTemplate.update(sql1,price,username);
    }
}

声明式事务管理属性

@Transacitional注解属性

事务传播行为Propagation：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播；

传播行为	描述
REQUIRED	如果当前存在事务，则加入该事务；否则，新建一个事务。
SUPPORTS	如果当前存在事务，则加入该事务；否则，以非事务方式执行。
MANDATORY	要求当前存在事务，如果不存在则抛出异常。
REQUIRES_NEW	无论当前是否存在事务，都会创建一个新的事务。
NOT_SUPPORTED	以非事务方式执行方法，如果当前存在事务，则将其挂起。
NEVER	以非事务方式执行方法，如果当前存在事务，则抛出异常。
NESTED	如果当前存在事务，则在一个嵌套的事务中执行；如果没有事务，则按REQUIRED行为创建一个新事务。

事务隔离级别：一个事务与其他事务之间的隔离等级

隔离级别	描述
DEFAULT (使用数据库默认)	使用数据库的默认隔离级别（通常为数据库配置的默认级别）。
READ_UNCOMMITTED (读未提交)	允许读取尚未被其他事务提交的数据，存在脏读和不可重复读的风险。
READ_COMMITTED (读已提交)	只能读取已经被其他事务提交的数据，避免脏读，但仍可能存在不可重复读。
REPEATABLE_READ (可重复读)	确保在事务执行期间，其他事务不能修改数据，避免脏读和不可重复读。
SERIALIZABLE (串行化)	最高隔离级别，确保事务串行执行，避免脏读、不可重复读和幻读。

事务超时：设置超时时间，到达设置的时间之后会强制事务回滚；类型int，单位秒；默认值-1未设置强制回滚时间
事务只读：一般事务中只有查询操作时才会设置事务只读
事务回滚：rollbackFor，设置回滚的异常class；norollbackFor，不设置回滚异常的class。

基于xml配置声明式事务管理


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

    <context:component-scan base-package="com.acaiblog.spring"/>

    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
     bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    bean>

    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    bean>

    <tx:annotation-driven>tx:annotation-driven>

    <tx:advice id="tx" transaction-manager="transactionManager">

        <tx:attributes>

            <tx:method name="find*" read-only="true"/>
        tx:attributes>
    tx:advice>
beans>

你可能感兴趣的:(spring,java,后端)

Java中的批处理优化：使用Spring Batch处理大规模数据的实践微赚淘客系统开发者@聚娃科技 java spring batch
Java中的批处理优化：使用SpringBatch处理大规模数据的实践大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在处理大规模数据的场景中，批处理是一个非常常见且必要的操作。Java中的SpringBatch是一个强大的框架，能够帮助我们高效地执行复杂的批处理任务。本文将带大家了解如何使用SpringBatch处理大规模数据，并通过代码示例展示如何实现高效的批
js递归性能优化啃火龙果的兔子开发DEMO javascript 开发语言 ecmascript
JavaScript递归性能优化递归是编程中强大的技术，但在JavaScript中如果不注意优化可能会导致性能问题甚至栈溢出。以下是几种优化递归性能的方法：1.尾调用优化(TailCallOptimization,TCO)ES6引入了尾调用优化，但只在严格模式下有效：'usestrict';//普通递归functionfactorial(n){if(n===1)return1;returnn*fa
2025 VUE常见面试题 hmildj vue.js 面试前端
前言总结一些VUE面试的基础知识，共同学习1.什么是Vue？答案：Vue.js（通常简称为Vue）是一个用于构建用户界面的‌渐进式JavaScript框架，Vue3是Vue.js框架的最新版本，它引入了许多改进和优化，包括性能提升、更好的类型支持、组合API等。2.MVVM模式是什么？Vue如何体现这一模式？‌答案：MVVM将视图（View）与数据（Model）通过ViewModel层解耦，Vue
Java静态static详解 Obltv Java基础 java
更多内容请看我的个人网站date:2025-06-04tags:八股基础静态变量特点被该类的所有对象共享不属于对象，属于类优先于对象存在，随着类的加载而加载调用方式类名调用对象名调用（不推荐）静态方法没有this关键字publicclassStudent{privateStringname;privateintage;privateStringteacherName;publicvoidshow(
Java中多态的一些见解
更多内容请看我的个人网站多态初识调用成员的特点成员变量：编译看左边，运行看左边成员方法：编译看左边，运行看右边多态在调用成员变量时为什么是父类的，但是方法是子类的?一句话解释：在编译时（静态绑定），成员变量是根据引用类型（也就是声明的类型）来决定的；在运行时（动态绑定），方法是根据对象的实际类型（也就是new出来的类型）来决定的。举个经典例子classParent{publicStringname
Java中的值传递 Obltv Java基础 java 开发语言
更多内容请看我的个人网站date:2025-06-01tags:八股基础Java中只有值传递什么是值传递值传递（PassbyValue）调用方法时，传递的是参数的值，是原始数据的一个副本。方法内部改变这个副本，不影响原始数据。什么是引用传递引用传递（PassbyReference）调用方法时，传递的是变量的地址（指针），方法内部对这个引用的任何更改，都会影响原始对象的引用。举例一个方法不能修改一个
Spring Batch ：高效处理海量数据的利器一叶飘零_sweeeet Springboot spring boot
SpringBatch是Spring框架中一个功能强大的批处理框架，旨在帮助开发人员轻松处理大量数据的批量操作，比如数据的导入、导出、转换以及定期的数据清理等任务。它提供了一套完善且灵活的机制，使得原本复杂繁琐的数据批处理工作变得条理清晰、易于管理和扩展。接下来，我们将全方位深入探究SpringBatch，从其核心概念、架构组成，到具体的使用示例以及在不同场景下的应用优势等，带你充分领略它的魅力所
平台再升级！接入DeepSeek AI，三大能力一键生成橙武科技低代码 AI deepseek 人工智能
在数字化项目落地过程中，很多企业都会面临相同的问题：数据库建模要写SQL表结构；业务流程需要画LogicFlow流程图；前端页面还要写AMISJSON配置。从想法到实现，中间至少要经历产品经理、架构师、后端、前端多轮沟通。每个环节都耗时，改起来还要推翻重来。demo地址：https://admin.cwcode.top✨我们的平台，现在直接整合了DeepSeekAI大模型只要输入一句需求，就能：✅
代码随想录算法训练营第52天 | 101.孤岛的总面积、102.沉没孤岛、103.水流问题、104.建造最大岛屿 Amor_Fati_Yu 算法 java 数据结构
101.孤岛的总面积importjava.util.*;publicclassMain{privatestaticintcount=0;privatestaticfinalint[][]dir={{0,1},{1,0},{-1,0},{0,-1}};//四个方向privatestaticvoidbfs(int[][]grid,intx,inty){Queueque=newLinkedList=gr
将字符串数组String[]转换成List的三种方法积极向上的Elbert java学习 java 开发语言
通过Arrays.asList(strArray)方式,将数组转换List后，不能对List增删，只能查改，否则抛异常。String[]strArray=newString[2];Listlist=Arrays.asList(strArray)；list.add("1");//此处会报错原因解析：Arrays.asList(strArray)返回值是java.util.Arrays类中一个私有静态
Java Fork/Join 框架详解 empti_ 数据结构与算法 java
JavaFork/Join框架详解Fork/Join框架是Java7引入的一个并行编程框架，专门设计用来高效地实现分治算法（Divide-and-Conquer）。它通过工作窃取（Work-Stealing）算法来最大化多核处理器的利用率。一、核心概念1.基本组成ForkJoinPool：特殊的线程池，管理工作线程ForkJoinTask：表示任务的抽象类，有两个重要子类：RecursiveAct
Java注解的实现原理 empti_ Java基础 java
Java注解的实现原理Java注解的实现涉及Java语言规范、编译器处理和JVM支持等多个层面。下面我将详细解释注解在Java中的实现机制。一、注解的本质注解本质上是一种特殊的接口，所有注解类型都隐式继承自java.lang.annotation.Annotation接口。当你定义一个注解时：public@interfaceMyAnnotation{Stringvalue();}编译器实际上会生成
MCP-Proxy：开发多LLM & 多MCP 支持并安全访问MCP Server的秘密 IT古董技术杂谈安全 MCP MCP-Proxy
在构建多模型、多协议、可控可信的大模型接入平台时，MCP-Proxy扮演着关键中枢。它不仅要支持多个LLM接入，还要保障对后端MCPServer的安全访问、请求审计、能力切换与资源隔离。什么是MCP/MCP-Proxy？MCP（ModelCapabilityProtocol）是新一代模型能力调用协议，类似于OpenAI的API，但可支持：多厂商大模型（OpenAI、DeepSeek、Yi、Chat
Spring AI快速入门学java的cc spring 大数据 java
一、引入依赖org.springframework.aispring-ai-starter-model-openaiorg.springframework.aispring-ai-bom${spring-ai.version}pomimport二、配置模型spring：ai:openai:base-url:https://dashscope.aliyuncs.com/compatible-mode
并行归并排序的 Java 实现 empti_ 数据结构与算法 java 算法排序算法
并行归并排序Java实现importjava.util.concurrent.RecursiveAction;importjava.util.concurrent.ForkJoinPool;publicclassParallelMergeSort{//主方法，供外部调用publicstaticvoidparallelMergeSort(int[]array){ForkJoinPoolpool=ne
Spring Cloud 微服务架构部署模式 Java技术栈实战架构 spring cloud 微服务 ai
SpringCloud微服务架构部署模式：从单体到云原生的进化路径关键词：SpringCloud、微服务架构、部署模式、容器化、Kubernetes、服务网格、DevOps摘要：本文系统解析SpringCloud微服务架构的核心部署模式，涵盖传统物理机部署、容器化部署、Kubernetes集群编排、服务网格集成等技术栈。通过技术原理剖析、实战案例演示和最佳实践总结，揭示不同部署模式的适用场景、技术
Spring Boot项目初始化加载自定义配置文件内容到静态属性字段 @Corgi Java面试题 spring boot 后端 java
文章目录创建配置文件cXXX.properties配置类XXXConfig.java添加第三方JAR包创建配置文件cXXX.properties在resource目录下新建配置文件cXXX.properties，内容如下：#商户号mch_id=xxxxx#商户密码pwd=xxxx#接口请求地址req_url=https://xxx#异步回调通知地址（请替换为实际地址）notify_url=htt
三阶落地：腾讯云Serverless+Spring Cloud的微服务实战架构大熊计算机 #腾讯云架构腾讯云 serverless
云原生演进的关键挑战（1）传统微服务架构痛点资源利用率低（非峰值期资源闲置率>60%）运维复杂度高（需管理数百个容器实例）突发流量处理能力弱（扩容延迟导致P99延迟飙升）（2）Serverless的破局价值腾讯云SCF（ServerlessCloudFunction）提供：毫秒级计费粒度（成本下降40%~70%）百毫秒级弹性伸缩（支持每秒万级并发扩容）零基础设施运维同步调用异步事件用户请求API网
RAG 调优指南：Spring AI Alibaba 模块化 RAG 原理与使用 ApacheDubbo spring 人工智能架构 Spring AI RAG
>夏冬,SpringAIAlibabaContributorRAG简介什么是RAG（检索增强生成）RAG（RetrievalAugmentedGeneration，检索增强生成）是一种结合信息检索和文本生成的技术范式。核心设计理念RAG技术就像给AI装上了「实时百科大脑」，通过先查资料后回答的机制，让AI摆脱传统模型的"知识遗忘"困境。️四大核心步骤1.文档切割→建立智能档案库核心任务:将海量文档
Nginx与Tomcat：谁更适合你的服务器？当归1024 java 中间件 nginx nginx tomcat 服务器
nginx和Tomcat是两种不同类型的服务器软件，它们各有不同的用途和特点：基本定义nginx轻量级的HTTP服务器和反向代理服务器主要用于静态文件服务、负载均衡、反向代理TomcatJavaWeb应用服务器专门用于运行JavaWeb应用（JSP、Servlet）主要区别1.功能定位nginx：静态文件服务器反向代理服务器负载均衡器HTTP缓存服务器Tomcat：Java应用容器JSP/Serv
Spring AI Alibaba 支持国产大模型的Spring ai框架程序员老陈头面试学习路线阿里巴巴 spring 人工智能 java
总计30万奖金，SpringAIAlibaba应用框架挑战赛开赛点此了解SpringAI：java做ai应用的最好选择过去，Java在AI应用开发方面缺乏一个高效且易于集成的框架，这限制了开发者快速构建和部署智能应用程序的能力。SpringAI正是为解决这一问题而生，它提供了一套统一的接口，使得AI功能能够以一种标准化的方式被集成到现有的Java项目中。此外，SpringAI与原有的Spring生
Node.js 全局对象 froginwe11 开发语言
Node.js全局对象引言Node.js作为一种流行的JavaScript运行环境，以其高性能、轻量级和跨平台的特点，被广泛应用于服务器端编程、网络应用开发等领域。在Node.js中，全局对象是一个重要的概念，它为开发者提供了一系列内置的全局变量和方法，使得编程变得更加便捷。本文将详细介绍Node.js的全局对象，帮助开发者更好地理解和运用它们。Node.js全局对象概述Node.js的全局对象指
企业级AI开发利器：Spring AI框架深度解析与实战_spring ai实战 AI大模型-海文人工智能 spring python 算法开发语言 java 机器学习
企业级AI开发利器：SpringAI框架深度解析与实战一、前言：Java生态的AI新纪元在人工智能技术爆发式发展的今天，Java开发者面临着一个新的挑战：如何将大语言模型（LLMs）和生成式AI（GenAI）无缝融入企业级应用。传统的Java生态缺乏统一的AI集成方案，开发者往往需要为不同AI供应商（如OpenAI、阿里云、HuggingFace）编写大量重复的接口适配代码，这不仅增加了开发成本，
009 【入门】单双链表及其反转-堆栈诠释要天天开心啊算法专栏算法链表
链表与堆栈系统详解|[数据结构]-[中级]-[通用]一、基础概念与内存模型1.按值传递vs按引用传递|[Java]-[基础]-[内存]//[典型错误示例]-Java中的引用传递陷阱voidmodify(Nodenode){node=node.next;//[警告]错误！仅修改局部引用的指向，不影响原始链表}//[正确做法]-通过引用修改对象内部状态voidrealModify(Nodenode){
深度解析JavaScript 闭包 coding随想 JavaScript javascript 开发语言 ecmascript
深度解析JavaScript闭包引言：为什么闭包让人又爱又怕？在JavaScript的学习过程中，闭包（Closure）是一个绕不开的“坎”。很多开发者第一次接触闭包时，会感到一头雾水：“为什么函数能记住外部作用域的变量？”、“为什么闭包会导致内存泄漏？”。但另一方面，闭包又是JavaScript最强大的特性之一，它支撑着模块化开发、数据封装、异步编程等核心场景。本文将通过通俗的语言和生动的案例，
JavaScript中的函数柯里化（Currying）：从概念到实战 coding随想 JavaScript javascript ecmascript 开发语言前端
JavaScript中的函数柯里化（Currying）：从概念到实战在JavaScript开发中，函数式编程（FunctionalProgramming）逐渐成为一种主流思想。而函数柯里化（Currying），正是这一思想中的核心技巧之一。它不仅能提升代码的复用性和灵活性，还能帮助我们构建更优雅、更模块化的解决方案。本文将带你从零开始，深入理解柯里化的原理、实现方式及实际应用场景。一、什么是函数柯
webpack和vite区别 PromptOnce webpack 前端 node.js
一、Webpack1.概述Webpack是一个模块打包工具，它会递归地构建依赖关系图，并将所有模块打包成一个或多个bundle（包）。2.特点配置灵活：Webpack提供了高度可定制的配置文件，可以根据项目需求进行各种优化。生态系统丰富：Webpack拥有庞大的插件和加载器生态系统，可以处理各种资源类型（JavaScript、CSS、图片等）。支持代码拆分：通过代码拆分和懒加载，Webpack可以
uniapp处理后端返回的html字符串萌新咦～ uni-app
前言：采用v-html方法处理1.处理前↵↵document.forms[0].submit();2.处理后↵↵document.forms[0].submit();3.跳转页面方法//传参uni.setStorageSync("ICBC_GW_V3_HTML",res.result.payUrl)//跳转uni.navigateTo({url:"/subpages/cashier/webView
javascript 动态画心加文字 das白 #javascript javascript 动态心型线文字
测试//铺满屏幕varwidth=document.documentElement.clientWidth;varheight=document.documentElement.clientHeight;document.getElementById("gycanvas").setAttribute("width",width);document.getElementById("gycanvas"
javascript 动态画心 das白 #javascript javascript 动态心型线
测试canvas{background:lawngreen;//画布背景色}//铺满屏幕varwidth=document.documentElement.clientWidth;varheight=document.documentElement.clientHeight;document.getElementById("gycanvas").setAttribute("width",width
jsonp 常用util方法 hw1287789687 jsonp jsonp常用方法 jsonp callback
jsonp 常用java方法 (1)以jsonp的形式返回:函数名(json字符串) /*** * 用于jsonp调用 * @param map : 用于构造json数据 * @param callback : 回调的javascript方法名 * @param filters : <code>SimpleBeanPropertyFilter theFilt
多线程场景 alafqq 多线程
0 能不能简单描述一下你在java web开发中需要用到多线程编程的场景？0 对多线程有些了解，但是不太清楚具体的应用场景，能简单说一下你遇到的多线程编程的场景吗？ Java多线程 2012年11月23日 15:41 Young9007 Young9007 4 0 0 4 Comment添加评论关注(2) 3个答案按时间排序按投票排序 0 0 最典型的如： 1、
Maven学习——修改Maven的本地仓库路径 Kai_Ge maven
安装Maven后我们会在用户目录下发现.m2 文件夹。默认情况下，该文件夹下放置了Maven本地仓库.m2/repository。所有的Maven构件(artifact)都被存储到该仓库中，以方便重用。但是windows用户的操作系统都安装在C盘，把Maven仓库放到C盘是很危险的，为此我们需要修改Maven的本地仓库路径。
placeholder的浏览器兼容 120153216 placeholder
【前言】自从html5引入placeholder后，问题就来了，不支持html5的浏览器也先有这样的效果，各种兼容，之前考虑，今天测试人员逮住不放，想了个解决办法，看样子还行，记录一下。【原理】不使用placeholder，而是模拟placeholder的效果，大概就是用focus和focusout效果。【代码】 <scrip
debian_用iso文件创建本地apt源 2002wmj Debian
1.将N个debian-506-amd64-DVD-N.iso存放于本地或其他媒介内，本例是放在本机/iso/目录下 2.创建N个挂载点目录如下： debian:~#mkdir –r /media/dvd1 debian:~#mkdir –r /media/dvd2 debian:~#mkdir –r /media/dvd3 …. debian:~#mkdir –r /media
SQLSERVER耗时最长的SQL 357029540 SQL Server
对于DBA来说，经常要知道存储过程的某些信息： 1. 执行了多少次 2. 执行的执行计划如何 3. 执行的平均读写如何 4. 执行平均需要多少时间列名 &
com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 7454103 eclipse
今天eclipse突然报了com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 错误，并且工程文件打不开了，在网上找了一下资料，然后按照方法操作了一遍，好了，解决方法如下：错误提示信息： An error has occurred.See error log for more details. Reason: com/genuitec/
用正则删除文本中的html标签 adminjun java html 正则表达式去掉html标签
使用文本编辑器录入文章存入数据中的文本是HTML标签格式，由于业务需要对HTML标签进行去除只保留纯净的文本内容，于是乎Java实现自动过滤。如下： public static String Html2Text(String inputString) { String htmlStr = inputString; // 含html标签的字符串 String textSt
嵌入式系统设计中常用总线和接口 aijuans linux 基础
嵌入式系统设计中常用总线和接口任何一个微处理器都要与一定数量的部件和外围设备连接，但如果将各部件和每一种外围设备都分别用一组线路与CPU直接连接，那么连线
Java函数调用方式——按值传递 ayaoxinchao java 按值传递对象基础数据类型
Java使用按值传递的函数调用方式，这往往使我感到迷惑。因为在基础数据类型和对象的传递上，我就会纠结于到底是按值传递，还是按引用传递。其实经过学习，Java在任何地方，都一直发挥着按值传递的本色。首先，让我们看一看基础数据类型是如何按值传递的。 public static void main(String[] args) { int a = 2;
ios音量线性下降 bewithme ios音量
直接上代码吧 //second 几秒内下降为0 - (void)reduceVolume:(int)second { KGVoicePlayer *player = [KGVoicePlayer defaultPlayer]; if (!_flag) { _tempVolume = player.volume;
与其怨它不如爱它 bijian1013 选择理想职业规划
抱怨工作是年轻人的常态，但爱工作才是积极的心态，与其怨它不如爱它。一般来说，在公司干了一两年后，不少年轻人容易产生怨言，除了具体的埋怨公司“扭门”，埋怨上司无能以外，也有许多人是因为根本不爱自已的那份工作，工作完全成了谋生的手段，跟自已的性格、专业、爱好都相差甚远。
一边时间不够用一边浪费时间 bingyingao 工作时间浪费
一方面感觉时间严重不够用，另一方面又在不停的浪费时间。每一个周末，晚上熬夜看电影到凌晨一点，早上起不来一直睡到10点钟，10点钟起床，吃饭后玩手机到下午一点。精神还是很差，下午像一直野鬼在城市里晃荡。为何不尝试晚上10点钟就睡，早上7点就起，时间完全是一样的，把看电影的时间换到早上，精神好，气色好，一天好状态。控制让自己周末早睡早起，你就成功了一半。有多少个工作
【Scala八】Scala核心二：隐式转换 bit1129 scala
Implicits work like this: if you call a method on a Scala object, and the Scala compiler does not see a definition for that method in the class definition for that object, the compiler will try to con
sudoku slover in Haskell (2) bookjovi haskell sudoku
继续精简haskell版的sudoku程序，稍微改了一下，这次用了8行，同时性能也提高了很多，对每个空格的所有解不是通过尝试算出来的，而是直接得出。 board = [0,3,4,1,7,0,5,0,0, 0,6,0,0,0,8,3,0,1, 7,0,0,3,0,0,0,0,6, 5,0,0,6,4,0,8,0,7,
Java-Collections Framework学习与总结-HashSet和LinkedHashSet BrokenDreams linkedhashset
本篇总结一下两个常用的集合类HashSet和LinkedHashSet。它们都实现了相同接口java.util.Set。Set表示一种元素无序且不可重复的集合；之前总结过的java.util.List表示一种元素可重复且有序
读《研磨设计模式》-代码笔记-备忘录模式-Memento bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; /* * 备忘录模式的功能是，在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，为以后的状态恢复作“备忘”
《RAW格式照片处理专业技法》笔记 cherishLC PS
注意，这不是教程！仅记录楼主之前不太了解的一、色彩（空间）管理作者建议采用ProRGB（色域最广），但camera raw中设为ProRGB，而PS中则在ProRGB的基础上，将gamma值设为了1.8（更符合人眼）注意：bridge、camera raw怎么设置显示、输出的颜色都是正确的（会读取文件内的颜色配置文件），但用PS输出jpg文件时，必须先用Edit->conv
使用 Git 下载 Spring 源码编译 for Eclipse crabdave eclipse
使用 Git 下载 Spring 源码编译 for Eclipse 1、安装gradle，下载 http://www.gradle.org/downloads 配置环境变量GRADLE_HOME，配置PATH %GRADLE_HOME%/bin，cmd，gradle -v 2、spring4 用jdk8 下载 https://jdk8.java.
mysql连接拒绝问题 daizj mysql 登录权限
mysql中在其它机器连接mysql服务器时报错问题汇总一、[running][email protected]:~$mysql -uroot -h 192.168.9.108 -p //带-p参数，在下一步进行密码输入 Enter password: //无字符串输入 ERROR 1045 (28000): Access
Google Chrome 为何打压 H.264 dsjt apple html5 chrome Google
Google 今天在 Chromium 官方博客宣布由于 H.264 编解码器并非开放标准，Chrome 将在几个月后正式停止对 H.264 视频解码的支持，全面采用开放的 WebM 和 Theora 格式。 Google 在博客上表示，自从 WebM 视频编解码器推出以后，在性能、厂商支持以及独立性方面已经取得了很大的进步，为了与 Chromium 现有支持的編解码器保持一致，Chrome
yii 获取控制器名和方法名 dcj3sjt126com yii framework
1. 获取控制器名在控制器中获取控制器名: $name = $this->getId(); 在视图中获取控制器名: $name = Yii::app()->controller->id; 2. 获取动作名在控制器beforeAction()回调函数中获取动作名: $name =
Android知识总结（二） come_for_dream android
明天要考试了，速速总结如下 1、Activity的启动模式 standard：每次调用Activity的时候都创建一个（可以有多个相同的实例，也允许多个相同Activity叠加。） singleTop：可以有多个实例，但是不允许多个相同Activity叠加。即，如果Ac
高洛峰收徒第二期：寻找未来的“技术大牛” ——折腾一年，奖励20万元 gcq511120594 工作项目管理
高洛峰，兄弟连IT教育合伙人、猿代码创始人、PHP培训第一人、《细说PHP》作者、软件开发工程师、《IT峰播》主创人、PHP讲师的鼻祖！首期现在的进程刚刚过半，徒弟们真的很棒，人品都没的说，团结互助，学习刻苦，工作认真积极，灵活上进。我几乎会把他们全部留下来，现在已有一多半安排了实际的工作，并取得了很好的成绩。等他们出徒之日，凭他们的能力一定能够拿到高薪，而且我还承诺过一个徒弟，当他拿到大学毕
linux expect heipark expect
1. 创建、编辑文件go.sh #!/usr/bin/expect spawn sudo su admin expect "*password*" { send "13456\r\n" } interact 2. 设置权限 chmod u+x go.sh 3.
Spring4.1新特性——静态资源处理增强 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
idea ubuntuxia 乱码 liyonghui160com
1.首先需要在windows字体目录下或者其它地方找到simsun.ttf 这个字体文件。 2.在ubuntu 下可以执行下面操作安装该字体： sudo mkdir /usr/share/fonts/truetype/simsun sudo cp simsun.ttf /usr/share/fonts/truetype/simsun fc-cache -f -v
改良程序的11技巧 pda158 技巧
有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：尽量保持方法简短永远永远不要把同一个变量用于多个不同的
300个涵盖IT各方面的免费资源（下）——工作与学习篇 shoothao 创业免费资源学习课程远程工作
工作与生产效率: A. 背景声音 Noisli:背景噪音与颜色生成器。 Noizio:环境声均衡器。 Defonic:世界上任何的声响都可混合成美丽的旋律。 Designers.mx:设计者为设计者所准备的播放列表。 Coffitivity:这里的声音就像咖啡馆里放的一样。 B. 避免注意力分散 Self Co
深入浅出RPC uule rpc
深入浅出RPC-浅出篇深入浅出RPC-深入篇 RPC Remote Procedure Call Protocol 远程过程调用协议它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发

Spring框架

Spring初识

Spring简介

Spring核心概念

搭建Spring框架工程

Spring特性

Spring获取bean的三种方式

Bean标签

SpringIOC底层实现

BeanFactory与ApplicationContext

Spring数值的注入方式

set注入

构造器注入

名称空间注入

外部已声明bean

bean级联属性赋值

内部bean属性赋值

bean List集合注入赋值

bean Map集合注入赋值

Spring管理第三方bean

Spring管理druid

Spring FactoryBean

Spring Bean的作用域

Spring Bean生命周期

Bean的后置处理器

Spring基于xml自动装配

环境搭建

byName自动装配

byType自动装配

总结

Spring中的注解

搭建环境

使用注解将对象装配到IOC容器中

注解实现步骤

使用注解装配对象中的属性[自动装配]

@Autowired

@Qualifier

Spring组件扫描

Spring完全注解开发

实现步骤

Spring集成Junit4

Spring AOP

AspectJ框架

切入点表达式

JoinPoint对象

AspectJ 通知

定义切面的优先级

使用AspectJ框架

JDBCTemplate

基本使用

JDBCTemplate常用API

设计数据库表结构

增加数据

修改数据

删除数据

批量增加

查询

Spring声明式事务管理

编程式事务管理

声明式事务管理【AOP管理事务】

使用声明式事务管理

声明式事务管理属性

基于xml配置声明式事务管理

你可能感兴趣的:(spring,java,后端)

使用注解装配对象中的属性`[自动装配]`