Spring框架使用详解（一）

已于 2023-08-16 13:13:30 修改
阅读量841 收藏 4
点赞数
文章标签： spring java
于 2023-08-16 11:34:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jay_musu/article/details/132300432
版权

目录

一、Spring的介绍

1. 背景

2. 优势

3. 作用

二、Spring应用

1. 引入相关依赖

 2. applicationContext.xml配置文件

3. IOC容器使用

（1）创建一个用户类

（2）实例化类并输出

（3）获取容器中的bean对象并输出

（4）输出结果如下

4. 依赖注入

（1）setter注入

（2）构造方法注入

（3）命名空间注入

（4）复杂注入

 5. Bean的其他属性和生命周期

（1）属性介绍

（2）生命周期

（3）使用示例

（4）小结

6. 实例化方式

（1）构造方法实例化bean

（2）使用静态方法实例化bean

（3）使用实例化工厂实例化bean

（4）使用FactoryBean实例化bean

7. 使用Spring配置数据源

8. spring配置文件常用标签

三、Spring注解编程

1. spring常用注解

2. spring配置类注解使用

（1）配置Spring配置类

（2）使用注解注册bean和属性注入

（3）测试输入（注解方式）

（4）配置第三方类

四、总结

一、Spring的介绍

1. 背景

        Spring 框架最早由 Rod Johnson 在 2002 年创立，起初是为了解决 EJB（Enterprise JavaBeans）的繁琐和复杂性。随着时间的推移，Spring 框架逐渐发展成为一个全面的企业级应用框架，提供了从基本的控制反转（IoC）容器到数据访问、事务管理、Web 开发、安全性、集成等各个领域的支持。

2. 优势

  • 控制反转（IoC）和依赖注入（DI）： Spring 使用 IoC 容器来管理应用程序中的对象，解决了传统的对象创建和管理的问题。通过依赖注入，开发者可以将组件之间的依赖关系从代码中解耦，使代码更加清晰、模块化和可测试。

  • 声明式事务管理： Spring 提供了声明式事务管理，使得开发者可以通过配置而不是硬编码来管理事务。这简化了事务管理，提高了代码的可读性和可维护性。

  • AOP（面向切面编程）支持： Spring 支持面向切面编程，允许开发者通过切面将横切关注点（如日志记录、性能监控）与核心业务逻辑分开，提高了代码的模块化和复用性。

  • 集成支持： Spring 提供了广泛的集成支持，包括对持久化框架（JDBC、JPA、Hibernate）、消息队列（JMS）、Web 框架（Spring MVC）等的无缝集成，帮助开发者构建综合性的应用。

  • 模块化： Spring 框架被分成多个模块，开发者可以根据项目需要选择性地使用不同模块，避免了不必要的复杂性。

3. 作用

  • 构建 Web 应用程序：Spring MVC 提供了一个强大的 Web 框架，用于构建响应式的、灵活的 Web 应用程序。

  • 数据访问：Spring 提供了对 JDBC、JPA、Hibernate 等持久化框架的集成支持，简化了数据访问层的开发。

  • 事务管理：通过声明式事务管理，可以简化数据库事务的管理，确保数据的一致性和完整性。

  • 面向切面编程：使用 Spring 的 AOP 支持，可以在不修改核心业务逻辑的情况下，将横切关注点（如日志、安全性）与业务逻辑分开。

  • 集成第三方库：Spring 提供了丰富的集成支持，可以轻松地将第三方库（如消息队列、搜索引擎、缓存）集成到应用中。

  • 企业级应用开发：Spring 框架提供了各种支持，使开发者能够构建稳健、可扩展的企业级应用程序。

二、Spring应用

1. 引入相关依赖

  • spring核心依赖（目前版本最新6.0.11）
  <!-- Spring 上下文和 AOP，已经包含了 spring-core 和 spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-version}</version> <!-- 请根据实际版本调整 -->
        </dependency>
  • 版本控制
<!--    控制锁定当前模块/项目某块的版本号-->
    <properties>
<!--        spring框架相关的版本-->
        <spring-version>6.0.11</spring-version>
    </properties>
  • spring和jdk版本对应关系

 2. applicationContext.xml配置文件

构建maven项目后，在resources目录下创建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 http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

3. IOC容器使用

（1）创建一个用户类

package com.jay.entity;
/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 16:05
 * @PackageName com.jay.entity
 * @ClassName TUser
 * @Description 用户实体类
 */

public class TUser {
    private Integer userId;
    private String name;

    public TUser(Integer userId, String name) {
        this.userId = userId;
        this.name = name;
    }

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

    public TUser() {
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

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

（2）实例化类并输出

        传统方式中，我们需要先通过new TUse()的方式才能获取到用户对象 ，而现在通过IOC容器进行获取，在applicationContext.xml中通过添加bean标签并进行相关配置，以此来创建TUser用户对象，具体操作方法如下：

<?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="tUser" class="com.jay.entity.TUser"/>
</beans>

（3）获取容器中的bean对象并输出

 @Test
    public void test() {

        //通过Spring框架提供的加载器从类路径加载XML配置文件并创建应用上下文，可以加载和初始化Spring配置文件中定义的Bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //获取bean对象，通过id进行获取
        //这里获取了TUser对象，其id为tUser，然后进行强转
        TUser tUser = (TUser) context.getBean("tUser");

        //输出
        System.out.println(tUser);
    }

（4）输出结果如下

这里成功输出了TUser对象中的toString()方法，表示成功获取到了对象。

4. 依赖注入

        依赖注入（Dependency Injection，DI）是一种设计模式和编程技术，用于实现对象之间的解耦和依赖关系管理。在依赖注入中，对象的依赖关系不再由对象自身负责创建和管理，而是由外部的容器（通常是框架）来负责。其主要有以下几种注入方式：

（1）setter注入

        顾名思义，通过setter方法进行注入，也就是说前提是当前对象需要有setter方法才行，具体操作如下：

<?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="tUser" class="com.jay.entity.TUser">
        <property name="userId" value="10"/>
        <property name="name" value="张三"/>
    </bean>
</beans>

        继续上面的测试方法，输出如下：

（2）构造方法注入

        同理，需要有相应的构造方法才能进行注入，实现如下：

<?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="tUser" class="com.jay.entity.TUser">-->
<!--        <property name="userId" value="10"/>-->
<!--        <property name="name" value="张三"/>-->
<!--    </bean>-->


        <bean id="tUser" class="com.jay.entity.TUser">
            <constructor-arg name="userId" value="55"/>
            <constructor-arg name="name" value="李四"/>
        </bean>
</beans>

          继续上面的测试方法，输出如下：

        注意：构造方法注入要求明确指定依赖关系的参数顺序和数量，确保构造方法的参数与依赖关系一一对应，参数顺序应与构造函数中参数的顺序相匹配。

（3）命名空间注入

  • P 命名空间注入： 使用 P 命名空间（Property）来注入依赖关系。这种方式允许你在 XML 配置文件中以属性的形式直接为 Bean 的属性赋值（对应setter注入），示例如下：
  <bean id="tUser" class="com.jay.entity.TUser" p:name="李四" p:userId="12"/>
  • C 命名空间注入： 使用 C 命名空间（Constructor）来注入构造函数的参数值。这种方式允许你在 XML 配置文件中以构造函数参数的形式为 Bean 的构造函数参数赋值（对应构造注入），示例如下：
 <bean id="tUser" class="com.jay.entity.TUser" C:name="李四" C:userId="12"/>

（4）复杂注入

        当对象中某个属性不是基本类型或包装类等类型时，不能继续用value进行值的注入，这时候需要根据属性的类型进行不同的赋值方式。

  • 创建一个TClass教室对象，并添加需要进行测试的属性。
package com.jay.entity;

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

/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 16:55
 * @PackageName com.jay.entity
 * @ClassName THouse
 * @Description 房屋实体类对象
 */
public class TLog {
    private Integer logId;
    private String logContent;
    private TUser user;
    private List<String> logTagList;
    private String[] logArr;
    private Map<String,String> logMap;

    @Override
    public String toString() {
        return "TLog{" +
                "logId=" + logId +
                ", logContent='" + logContent + '\'' +
                ", user=" + user +
                ", logTagList=" + logTagList +
                ", logArr=" + Arrays.toString(logArr) +
                ", logMap=" + logMap +
                '}';
    }

    public TLog() {
    }

    public Integer getLogId() {
        return logId;
    }

    public void setLogId(Integer logId) {
        this.logId = logId;
    }

    public String getLogContent() {
        return logContent;
    }

    public void setLogContent(String logContent) {
        this.logContent = logContent;
    }

    public TUser getUser() {
        return user;
    }

    public void setUser(TUser user) {
        this.user = user;
    }

    public List<String> getLogTagList() {
        return logTagList;
    }

    public void setLogTagList(List<String> logTagList) {
        this.logTagList = logTagList;
    }

    public String[] getLogArr() {
        return logArr;
    }

    public void setLogArr(String[] logArr) {
        this.logArr = logArr;
    }

    public Map<String, String> getLogMap() {
        return logMap;
    }

    public void setLogMap(Map<String, String> logMap) {
        this.logMap = logMap;
    }
}
  • 编写配置文件，配置bean，并利用setter注入进行属性注入。
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="tUser" class="com.jay.entity.TUser" C:name="李四" C:userId="12"/>
    <bean id="tLog" class="com.jay.entity.TLog">
        <property name="logId" value="12"/>
        <property name="logContent" value="错误日志"/>

        <!-- 这里是注入一个对象，不能继续用value，得换成ref，其指向上面已经添加到容器中的TUser对象的id-->
        <property name="user" ref="tUser"/>

        <!-- 这里是注入一个数组-->
        <property name="logArr">
            <array>
                <value>123</value>
                <value>555</value>
                <value>777</value>
            </array>
        </property>

        <!-- 这里是注入一个List集合-->
        <property name="logTagList">
            <list>
                <value>123456</value>
                <value>787945</value>
                <value>555555</value>
            </list>
        </property>

        <!-- 这里是注入一个Map集合-->
        <property name="logMap">
            <map key-type="java.lang.String" value-type="java.lang.String">
                <entry key="123" value="555"/>
            </map>
        </property>
    </bean>




</beans>
  • 测试输出
package com.jay;

import com.jay.entity.TLog;
import com.jay.entity.TUser;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 17:09
 * @PackageName com.jay
 * @ClassName TLogTest
 * @Description 日志测试类
 */
public class TLogTest {
    @Test
    public void test() {

        //通过Spring框架提供的加载器从类路径加载XML配置文件并创建应用上下文，可以加载和初始化Spring配置文件中定义的Bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //获取bean对象，通过id进行获取
        //这里获取了TUser对象，其id为tUser，然后进行强转
        TLog tLog = (TLog) context.getBean("tLog");

        //输出
        System.out.println(tLog);
    }
}
  • 输出结果

 5. Bean的其他属性和生命周期

（1）属性介绍

  • scope:选择bean的创建模式

    • singleton:单例模式(默认)

    • prototype:原型模式(多例)

  • destroy-method:销毁时调用的方法

  • init-method:初始化方法

（2）生命周期

        实例化bean -> bean属性赋值 -> 初始化bean -> 使用bean -> 销毁bean

（3）使用示例

  • 创建一个Student类进行测试
package com.jay.pojo;
/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 17:31
 * @PackageName com.jay.pojo
 * @ClassName Student
 * @Description 
 */
public class Student {

    public Student() {
        System.out.println("构造方法");
    }

    public void init() {
        System.out.println("初始方法");
    }

    public void destroy() {
        System.out.println("销毁方法");
    }
    
    public void doSomething(){
        System.out.println("执行方法");
    }

}
  • 在xml文件中进行相关配置（默认模式）
 <bean id="student" class="com.jay.pojo.Student" init-method="init" destroy-method="destroy"/>
package com.jay;

import com.jay.entity.TLog;
import com.jay.pojo.Student;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 17:38
 * @PackageName com.jay
 * @ClassName StudentTest
 * @Description 
 */
public class StudentTest {

    @Test
    public void test_1() {
        //通过Spring框架提供的加载器从类路径加载XML配置文件并创建应用上下文，可以加载和初始化Spring配置文件中定义的Bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        Student student = (Student) context.getBean("student");
        System.out.println(student);
        student.doSomething();
        context.close();

    }
    @Test
    public void test_2() {
        //通过Spring框架提供的加载器从类路径加载XML配置文件并创建应用上下文，可以加载和初始化Spring配置文件中定义的Bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//        Student student = (Student) context.getBean("student");
//        System.out.println(student);
//        student.doSomething();
//        context.close();

    }
}

        测试结果一

        测试结果二

  • 在原型模式下进行测试 
    <bean id="student" class="com.jay.pojo.Student" init-method="init" destroy-method="destroy" scope="prototype"/>

         测试结果一

        测试结果二

（4）小结

        在未获取bean时（即只读取加载了配置文件），对于单例模式，会自动实例化已经配置的单例模式的bean对象，并进行赋值和初始化，对于通过ref引入的原型模式的bean只会进行初始化和赋值。而原型模式则不会进行bean的实例化操作，只有获取了某个bean后才会进行实例化。

        在上下文关闭时， 单例模式会调用定义的销毁方法，而原型模式不会随之销毁。

6. 实例化方式

（1）构造方法实例化bean

        即通过bean标签进行实例化对象。

 <bean class="com.jay.entity.TUser" id="tUser"/>

（2）使用静态方法实例化bean

public class OrderDaoFactory {
    //    方式二：静态方法-->
    public static OrderDao getOrderDao(){
        return new OrderDaoimpl();
    }
}
<bean id="orderDao" class="com.jay.factory.OrderDaoFactory" factory-method="getOrderDao"/>

（3）使用实例化工厂实例化bean

   public class OrderDaoFactory {
       //    方式三：工厂实例化
       public OrderDao getorderDao(){
           return new OrderDaoimpl();
       }
   }
 
  <bean id="orderFactory" class="com.jay.factory.OrderDaoFactory"/>
   <bean id="OrderDao" factory-bean="orderFactory" factory-method="getorderDao"/>

（4）使用FactoryBean实例化bean

   public class OrderDaoFactoryBean implements FactoryBean<OrderDao> {

       //    方式四：代替原始实例工厂中创建的方法
       public OrderDao getObject() throws Exception {
           return new OrderDaoimpl();
       }


       public Class<?> getObjectType() {
           return OrderDao.class;
       }

       //控制是否单例
       public boolean isSingleton() {
           return false;
       }
   }
 <bean id="orderdao" class="com.jay.OrderDaoFactoryBean"/>

7. 使用Spring配置数据源

  • 导入相关依赖
   <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>


<!--        建立一个jdbc的连接，没有连接池作用-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-version}</version>
        </dependency>


        <!--        c3p0连接池-->
        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>


<!--        druid连接池-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.18</version>
        </dependency>

<!--        dbcp连接池-->
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
  • 在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: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:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>


    <bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <!--        c3p0连接池的私有属性-->
        <property name="maxPoolSize" value="10"/>
        <property name="minPoolSize" value="5"/>
        <!--        关闭连接后，不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--        获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!--        当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

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

    <bean id="basicDataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>
  • 引入配置文件

        通过下面的标签引入properties配置文件。

 <context:property-placeholder location="classpath:jdbc.properties"/>
  • 配置文件内容（jdbc.properties）
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test_database?serverTimezone=GMT&useSSL=false
jdbc.username=root
jdbc.password=root

8. spring配置文件常用标签

  • <beans> 标签： <beans> 是 Spring 配置文件的根元素，用于包含所有的配置内容。在该标签内部可以定义各种 Bean，配置依赖关系、切面等。

  • <bean> 标签： <bean> 标签用于定义一个 Spring Bean。你可以在这里配置 Bean 的 ID、类名、作用域、属性、依赖关系等。

  • <import> 标签： <import> 标签用于导入其他 Spring 配置文件，以便在一个配置文件中组合多个配置。

  • <property> 标签： <property> 标签用于在 Bean 配置中设置属性的值。可以使用该标签为 Bean 的属性赋予值，包括基本类型、字符串、引用等。

  • <constructor-arg> 标签： <constructor-arg> 标签用于在构造方法注入中指定参数的值。可用于构造方法参数的注入。

  • <alias> 标签： <alias> 标签用于为 Bean 定义一个别名，可以让你在应用中使用不同的名称来引用同一个 Bean。

  • <qualifier> 标签： <qualifier> 标签用于限定符注入，当存在多个相同类型的 Bean 时，可以使用限定符指定具体注入哪个 Bean。

  • <property-placeholder> 标签： <property-placeholder> 标签用于在配置文件中引用外部属性文件中的属性值，方便在配置文件中进行属性的动态配置。

  • <util:list> 和 <util:set> 标签： 这些标签用于定义列表和集合类型的属性。可以用于注入集合类型的依赖关系。

  • <util:map> 和 <util:properties> 标签： 这些标签用于定义映射和属性类型的属性。可以用于注入映射和属性类型的依赖关系。

  • <context:component-scan> 标签： <context:component-scan> 标签用于配置自动扫描，以便 Spring 能够自动发现和注册带有 @Component 注解的 Bean。

  • <aop:config> 标签： <aop:config> 标签用于配置面向切面编程（AOP），定义切面、切点、通知等。

  • <tx:advice> 和 <tx:attributes> 标签： 这些标签用于配置声明式事务管理，定义事务通知和事务属性。

  • <mvc:annotation-driven> 标签： <mvc:annotation-driven> 标签用于配置 Spring MVC，启用基于注解的 MVC 控制器。

  • <mvc:view-resolvers> 标签： <mvc:view-resolvers> 标签用于配置 Spring MVC 的视图解析器，将逻辑视图名称解析为实际视图。

  • <mvc:resources> 标签： <mvc:resources> 标签用于配置 Spring MVC 的静态资源处理，如 CSS、JavaScript 文件等。

  • <mvc:interceptors> 标签： <mvc:interceptors> 标签用于配置 Spring MVC 的拦截器，用于处理请求的预处理和后处理。

  • <mvc:default-servlet-handler> 标签： <mvc:default-servlet-handler> 标签用于配置 Spring MVC 默认的 Servlet 处理，将请求转发给默认的 Servlet。

三、Spring注解编程

1. spring常用注解

  • @Component 注解： 将类标记为一个 Spring 组件，使其成为 Spring 容器管理的 Bean。通常用于标记普通的 POJO 类。

  • @Repository、@Service、@Controller 注解： 这些注解分别用于标记数据访问层、业务逻辑层和控制器层的 Bean。

  • @Autowired 注解： 用于自动装配依赖，将依赖对象注入到 Bean 中。

  • @Qualifier 注解： 用于在存在多个同类型 Bean 时，指定特定的 Bean 进行注入。

  • @Value 注解： 用于将属性值从配置文件中注入到 Bean 的属性。

  • @Configuration 注解： 声明一个配置类，类似于 XML 配置文件。

  • @Bean 注解： 在配置类中定义一个 Bean。

  • @Import 注解： 导入其他配置类。

  • @ComponentScan 注解： 指定要扫描的包路径，自动注册 Bean。

  • @Aspect 注解： 声明一个切面类，进行面向切面编程。

  • @Pointcut 注解： 定义切点，指定切面的连接点。

  • @Before、@After、@AfterReturning、@AfterThrowing、@Around 注解： 定义不同类型的通知（Advice）。

  • @Transactional 注解： 声明事务属性和行为。

  • @Scope 注解： 定义 Bean 的作用域。

  • @Lazy 注解： 延迟初始化 Bean。

  • @DependsOn 注解： 指定 Bean 依赖的其他 Bean。

  • @PropertySource 注解： 加载外部属性文件。

  • @Profile 注解： 激活指定的配置文件。

  • @Primary 注解： 在存在多个相同类型 Bean 时，指定首选的 Bean。

  • @Conditional 注解： 根据条件来决定是否创建 Bean。

  • @EnableTransactionManagement 注解： 启用声明式事务管理。

  • @ImportResource 注解： 导入 XML 配置文件。

注：使用spring注解编程时需要配置扫描，确保容器能够扫描到这些注解，在spring配置文件中的需要使用<context:component-scan base-package="com.jay"/>来进行扫描，而对于的注解则是@ComponentScan("com.jay")。

2. spring配置类注解使用

        在spring中，可以用纯注解来替代applicationContext.xml配置文件，以上面的实例进行为例，将配置文件全部替换为注解形式。

（1）配置Spring配置类

@Configuration
@ComponentScan("com.jay")
public class SpringConfig {
    
}

（2）使用注解注册bean和属性注入

package com.jay.entity;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 16:05
 * @PackageName com.jay.entity
 * @ClassName TUser
 * @Description 用户实体类
 */
@Component
public class TUser {
    @Value("11")
    private Integer userId;
    @Value("张三")
    private String name;

    public TUser(Integer userId, String name) {
        this.userId = userId;
        this.name = name;
    }

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

    public TUser() {
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

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


package com.jay.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

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

/**
 * @Author jay_mosu
 * @Date 2023/8/15 0015 16:55
 * @PackageName com.jay.entity
 * @ClassName THouse
 * @Description 房屋实体类对象
 */
@Component
public class TLog {
    @Value("123")
    private Integer logId;
    @Value("我是spring配置类测试内容")
    private String logContent;

    @Autowired
    private TUser tUser;


    @Override
    public String toString() {
        return "TLog{" +
                "logId=" + logId +
                ", logContent='" + logContent + '\'' +
                ", tUser=" + tUser +
                '}';
    }

    public TLog() {
    }

    public Integer getLogId() {
        return logId;
    }

    public void setLogId(Integer logId) {
        this.logId = logId;
    }

    public String getLogContent() {
        return logContent;
    }

    public void setLogContent(String logContent) {
        this.logContent = logContent;
    }

    public TUser gettUser() {
        return tUser;
    }

    public void settUser(TUser tUser) {
        this.tUser = tUser;
    }
}

（3）测试输入（注解方式）

        在测试前，先集成spring和junit4，依赖如下：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring-version}</version>
</dependency>

        测试类代码如下：

package com.jay;

import com.jay.config.SpringConfig;
import com.jay.entity.TLog;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @Author jay_mosu
 * @Date 2023/8/16 0016 11:19
 * @PackageName com.jay
 * @ClassName TLogConfigTest
 * @Description 
 */

@RunWith(SpringJUnit4ClassRunner.class)//集成
@ContextConfiguration(classes = SpringConfig.class)//指定配置文件
public class TLogConfigTest {

    @Autowired
    private TLog tLog;

    @Test
    public void name() {
        System.out.println(tLog);

    }
}

（4）配置第三方类

package com.jay.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * @Author jay_mosu
 * @Date 2023/8/16 0016 11:02
 * @PackageName com.jay.config
 * @ClassName SpringConfig
 * @Description Spring配置文件
 */
@Configuration
@ComponentScan(value = "com.jay")
public class SpringConfig {
    @Value("${jdbc.driver}")
    private String driverName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    //    普通的jdbc连接
    @Bean
    public DataSource driverManagerDataSource(){
        DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
        driverManagerDataSource.setDriverClassName(driverName);
        driverManagerDataSource.setUrl(url);
        driverManagerDataSource.setUsername(username);
        driverManagerDataSource.setPassword(password);
        return driverManagerDataSource;
    }


    //    c3p0连接池配置
    @Bean
    public DataSource comboPooledDataSource(){
        try {
            ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
            comboPooledDataSource.setDriverClass(driverName);
            comboPooledDataSource.setJdbcUrl(url);
            comboPooledDataSource.setUser(username);
            comboPooledDataSource.setPassword(password);
            return comboPooledDataSource;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }
    }


    //    druid连接池
    @Bean
    public DataSource druidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }


    //    dbcp连接池
    @Bean
    public DataSource basicDataSource(){
        BasicDataSource basicDataSource = new BasicDataSource();
        basicDataSource.setDriverClassName(driverName);
        basicDataSource.setUrl(url);
        basicDataSource.setUsername(username);
        basicDataSource.setPassword(password);
        return basicDataSource;
    }

}

四、总结

        Spring IoC 容器是 Spring 框架的核心之一，它提供了强大的对象管理、依赖注入、生命周期管理等功能，帮助开发人员创建松散耦合的应用程序，提高可维护性和可测试性。无论是传统的 XML 配置还是基于注解的配置，都可以使用 Spring IoC 容器来管理和维护对象。

jay_musu
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring框架-one(Spring框架介绍)
张子又
03-07 2917
01-【熟悉】Spring框架介绍 1 Spring核心 1，AOP：面向切面编程。扩展功能而不修改源代码。 UserDaoImpl { void addUser(){ //得到sqlSessionFactory //得到sqlSession //开启事务 //调用mybatis的api做添加 //提交事务 //关闭sqlSession } ...
Spring基本使用
CodingYoo的博客
10-30 1211
一、Spring 框架概述 spring 是分层的JavaSE/EE应用轻量级开源框架，以IOC（inverse of control : 控制反转）和AOP(Aspect Oriented programing: 面向切面 编程)为内核。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4EiLzPSa-1604023954117)(C:\Users\lph\Desktop\笔记\Spring笔记\picture\001.png)] 1.2、Spring的优势 1.方便解耦，
Spring最快速入门（超详细）！Spring基本认识和入门使用
最新发布
PsychoPass的博客
04-27 2949
spring是一种用于简化复杂的企业开发的轻量级框架（从目的来说），是一种轻量级IOC和AOP的容器框架spring官网spring官方中文文档官网。
快速入门使用spring详细步骤（介绍、导入依赖、第一个简单程序）
快乐学习
02-06 1万+
spring6.0版本对应17版本，spring5.0版本的jdk17版本或者以下都可以。一、spring介绍 二、spring使用步骤 （一）创建maven项目 （二）maven项目导入spring依赖 （三）开始编写第一个spring程序 spring是作为Java EE企业级开发很好的一个框架，这篇文章就来讲解一下怎么使用spring。ps：如果导入时间很长或者不成功，就退出idea，然后再进入重新导入一下，或者换一下其他的版本号。
Spring 最全入门教程详解
lucky_fd的博客
07-04 5048
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
Spring使用教程
weixin_74265534的博客
09-12 1135
一.容器相关BeanFactory是IOC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载。ApplicationContext接口是Spring容器的核心接口，初始化bean立即加载。ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能ApplicationContext接口常用初始化类：ClassPathXmlApplicationContext,FileSystemXmlApplication二.bean相关。
全网最详细的Spring入门教程
YoYoYoWhatIsUp的博客
10-21 1387
其实spring的来源就是一个词语，完全解耦，为什么叫做完全解耦，还得从两个类的调用说起，接口1的实现类，我们叫做类1，接口2的实现类，我们叫做类2，现在我们有一个前提条件，就是，类2里面去new类1，且把类1的方法给到类2使用，我们现在形容类2和类1有依赖关系，也就是类2要依赖类1，那么如果出现一个境况也就是如果类1发生了改变，那么我们如何去使用类2，那我们在使用类2的时候就需要去改变类2里面的代码，一方面需要从新new一次类1，二方面需要把类2里面的方法对应新的类1的方法。我们采用set注入的方式。
【JavaEE案例】初始Spring框架
weixin_66697650的博客
04-08 1241
【JavaEE案例】初始Spring框架 （1）Spring的入门程序：要求在控制台打印“张三：欢迎来到Spring”。 （2）依赖注入的应用：以属性setter方法注入为例，实现一个简单的登录验证。
Spring Framework框架（一）
weixin_44325527的博客
11-12 346
Spring Framework框架 一、Spring概述 1.spring 是什么 Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java
spring知识框架详解
07-29
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。 很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的...
spring整合Quartz框架过程详解
08-25
本文主要介绍了 Spring 整合 Quartz 框架的过程详解，包括 Quartz 框架的简介、Quartz 框架的使用和 Cron 表达式的使用。通过本文的学习，读者可以了解如何使用 Quartz 框架来实现定时任务的调度。
Spring Boot构建框架详解
08-28
Spring Boot 构建框架详解 Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用程序的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化...
spring框架，技术详解及使用指导
03-19
这篇“spring框架，技术详解及使用指导”可能涵盖了Spring的多个方面，包括但不限于以下几个关键知识点： 1. **依赖注入（Dependency Injection，DI）**：这是Spring的核心特性，通过DI，对象之间的耦合度降低，...
spring框架，技术详解及使用指导.pdf.zip
03-04
通过这个"Spring框架，技术详解及使用指导.pdf"文档，读者将能够深入理解Spring框架的各个组件和它们的工作原理，同时学习如何在实际项目中有效地应用Spring框架，从而提升开发效率和应用质量。无论你是初学者还是...
详解SpringBoot和SpringBatch 使用
08-27
Spring Boot 和 Spring Batch 使用详解 Spring Batch 是一个轻量级的、完善的批处理框架，旨在帮助企业建立健壮、高效的批处理应用。 Spring Batch 提供了大量可重用的组件，包括了日志、追踪、事务、任务作业统计...
Spring 入门教程
热门推荐
Oneby的博客
03-01 1万+
Spring 入门教程 1、参考资料 尚硅谷-Spring5框架最新版教程（idea版） 雷丰阳spring、springmvc、mybatis、spring一站式学习 项目地址：oneby1314/spring-learn 2、Spring 概述 2.1、Spring 框架概述 Spring 是轻量级的开源的 JavaEE 框架 Spring 为简化企业级开发而生，使用Spring，Javabean就可以实现很多以前要靠EJB才能实现的功能 Spring 有两个核心部分：IOC 和 AOP
一篇文带你入门SSM框架Spring开发！精彩干货不间断！
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
06-15 2232
Hello，你好呀，我是灰小猿！一个超会写bug的程序猿！ SSM框架相信很多学习java的小伙伴们已经非常熟悉了，作为现代企业级应用开发的主流框架，然而现在的SSM框架已经被大佬们认为是Java开发的入门级教学了，不会点SSM的技术，都不敢去外边找工作了。 所以今天来和大家分享一下到底什么是SSM框架，以及SSM框架的第一个S—Spring框架的基础入门，并且将会在之后的文章中继续和大家分享进阶深入，循序递进，层层套娃！为之后Java大牛之路奠定基础！ 一、什么是SSM框架？ 官方一点的话
Spring快速入门超详细讲解
南 阳 的博客
07-02 3725
在Spring框架规范中，所有由spring管理的对象都称之为Bean对象。Spring提供了以下多个注解，这些注解可以直接标注在java类上，将它们定义成Spring Bean。注解说明@Component该注解用于描述Spring中的Bean，它是一个泛化的概念，仅仅标识容器中的一 个组件（Bean），并且可以作用在任何层次，例如Service层、Dao层等，使用时只需将该注解标注在相应的类上即可。
spring框架知识详解
10-08
Spring是一个开源的Java框架，旨在简化企业级应用程序的开发。它提供了一种轻量级的解决方案，通过依赖注入和面向切面编程等技术来解决传统Java开发中的一些繁琐问题。 Spring框架的核心特点包括： 1. 控制反转（IoC）：Spring实现了控制反转，将对象之间的依赖交给容器来管理，降低了组件之间的耦合性，提高了代码的可重用性和可维护性。 2. 依赖注入（DI）：Spring通过依赖注入机制来完成对象之间的依赖关系注入，开发人员只需要声明依赖，而不需要自己实例化对象，提高了代码的可测试性和可插拔性。 3. 面向切面编程（AOP）：Spring支持面向切面编程，通过拦截器等机制来实现横切关注点的解耦，提高了代码的模块化和复用性。 4. 组件化：Spring提供了一些重要的组件，如控制器、模型、视图等，用于构建Web应用程序，并通过Spring MVC框架提供了一套强大而灵活的Web开发解决方案。 5. 事务管理：Spring提供了事务管理的支持，可以轻松地在代码中声明式地管理事务，保证数据的一致性和完整性。 6. 持久化支持：Spring集成了多种持久化框架，如Hibernate、MyBatis等，使得数据库操作更加便捷和高效。 7. 安全性管理：Spring提供了一套完整的安全性管理解决方案，包括身份认证、权限控制等，保护应用程序的安全性。 总而言之，Spring框架通过提供一系列功能和组件，简化了企业级应用程序的开发和管理。它的优点包括代码的可测试性、可重用性、可维护性和扩展性。同时，Spring拥有庞大的社区支持和丰富的库，为开发人员提供了充分的资源和帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值