spring基于注解的IOC配置

最新推荐文章于 2024-07-12 09:16:51 发布
最新推荐文章于 2024-07-12 09:16:51 发布
阅读量133 收藏
点赞数 1
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40945517/article/details/106932382
版权

spring基于注解的IOC配置

1. 常用IOC注解

1.1 常用IOC注解分类

曾经xml的配置

   <bean id="accountService" class="com.wyj.service.impl.AccountServiceImpl" 
   scope="" init-method="" destroy-method="">
 		<property name="" value=""/ ref=""></property>
   </bean>
  1. 用于创建对象的，他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
  2. 用于注入数据的，他们的作用就和在xml配置文件中bean标签中写一个<property>标签的作用是一样的
  3. 用于改变作用范围的，他们的作用就和在bean标签中使用scope属性实现的功能是一样的
  4. 和生命周期相关，他们的作用就和在bean标签中使用init-method和destory-method的作用是一样的

1.2 用于创建对象的

@Component
作用：用于把当前类对象存入spring容器中
属性：
value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
bean.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
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.wyj"></context:component-scan>
</beans>

@Controller：一般用在表现层
@Service：一般用在业务层
@Repository：一般用在持久层
以上三个注解他们的作用和属性与Component是一模一样
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

1.3 用于注入数据的

@Autowired
自动按照类型注入，只要容器中有唯一一个bean对象类型和要注入的变量类型匹配，就能注入成功；如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错；如果ioc容器中有多个类型匹配时，
在这里插入图片描述
出现位置：可以在变量上，也可以在方法上
在使用注解时，set方法就不是必须的了
@Qualifier
作用：
在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须和@Autowire 一起使用；但是给方法参数注入时，可以独立使用。
属性：
value：指定 bean 的 id。
@Resource
作用：
直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。
属性：
name：指定 bean 的 id。
@Value
作用：
注入基本数据类型和 String 类型数据的
属性：
value：用于指定值

1.4 用于改变作用范围的

@Scope
作用：
指定 bean 的作用范围。
属性：
value：指定范围的值。
取值：singleton prototype request session globalsession

1.5 和生命周期相关的（了解）

@PostConstruct：用于指定初始化方法。
@PreDestory：用于指定销毁方法。

2. spring的新注解

2.1 Configuration

作用：
用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationApplicationContext(有@Configuration 注解的类.class)。
当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
属性：
value:用于指定配置类的字节码

2.2 ComponentScan

我们已经把配置文件用类代替，但是如何配置创建容器时所需要的包呢？
作用：
用于指定 spring 在初始化容器时要扫描的包。作用和在 spring 的 xml 配置文件中的：
<context:component-scan base-package=“com.itheima”/>是一样的。
属性：
basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样。

@Configuration
@ComponentScan("com.itheima")
public class SpringConfiguration {
}

2.2 Bean

我们已经配置好了要扫描的包，但是数据源对象如何从配置文件中移除呢。
作用：
该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。
属性：
name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。
细节：
当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。
查找的方式和Autowired注解的作用是一样的

@Configuration
@ComponentScan("com.wyj")
public class SpringConfiguration {
    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner creatQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource(){
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/spring");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

2.3 Import

作用：
用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问题。
属性：
value[]：用于指定其他配置类的字节码。

@Configuration
@ComponentScan(basePackages = "com.itheima.spring")
@Import({ JdbcConfig.class})
public class SpringConfiguration {
}


@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
}

2.4 PropertySource

将创建数据源的配置文件写出来。
作用：
用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。
属性：
value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner creatQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource(){
        ComboPooledDataSource ds = new ComboPooledDataSource();
        try {
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root

2.5 Qualifier

作用：
可以在方法的形参中指定你要注入的数据源名称

3. XMLIOC案例

3.1 前期代码

  1. pom.xml文件导入坐标
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>
  1. 创建表和实体类
create table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);


public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;
	//get/set/tostring方法
   }
  1. 持久层接口和实现类
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 查询一个
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存操作
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新操作
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);
}

public class AccountDaoImpl implements IAccountDao {
    private QueryRunner runner;
    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public Account findAccountById(Integer accountId) {
        try {
            return runner.query("select * from account where id = ?",new BeanHandler<Account>(Account.class),accountId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void saveAccount(Account account) {
        try {
             runner.update("insert into account(name,money) values(?,?)",account.getName(),account.getMoney());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,money=? where id = ?",account.getName(),account.getMoney(),account.getId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void deleteAccount(Integer accountId) {
        try {
            runner.update("delete from account where id = ?",accountId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
  1. 业务层接口和实现类
public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 查询一个
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存操作
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新操作
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 删除
     * @param accountId
     */
    void deleteAccount(Integer accountId);
}

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }
}

3.2 编写spring的IOC配置

bean.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">

    <!--配置Service对象-->
    <bean id="accountService" class="com.wyj.service.impl.AccountServiceImpl">
        <!--注入的是dao对象-->
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置dao对象-->
    <bean id="accountDao" class="com.wyj.dao.impl.AccountDaoImpl">
        <!--注入QueryRunner对象-->
        <property name="runner" ref="runner"></property>
    </bean>
    <!--配置QueryRunner对象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

3.3 测试

/**
 * 使用junit单元测试：测试我们的配置
 */
public class AccountServiceTest {
    @Test
    public void testFindAll(){
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        //3.执行方法
        List<Account> accounts = as.findAllAccount();
        for (Account account : accounts) {
            System.out.println(account);
        }
    }
    @Test
    public void testFindOne(){
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        Account accountById = as.findAccountById(1);
        System.out.println(accountById);
    }
    @Test
    public void testSave(){
        Account account = new Account();
        account.setName("save");
        account.setMoney(1234f);
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        //3.执行方法
        as.saveAccount(account);
    }
    @Test
    public void testUpdate(){
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        Account accountById = as.findAccountById(4);
        System.out.println(accountById);
        accountById.setMoney(5555f);
        as.updateAccount(accountById);
    }
    @Test
    public void testDelete(){
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取业务层对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
       as.deleteAccount(4);
    }
}

4. 注解IOC案例

  1. 持久层实现类
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private QueryRunner runner;
    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public Account findAccountById(Integer accountId) {
        try {
            return runner.query("select * from account where id = ?",new BeanHandler<Account>(Account.class),accountId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void saveAccount(Account account) {
        try {
             runner.update("insert into account(name,money) values(?,?)",account.getName(),account.getMoney());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,money=? where id = ?",account.getName(),account.getMoney(),account.getId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
    public void deleteAccount(Integer accountId) {
        try {
            runner.update("delete from account where id = ?",accountId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
  1. 业务层实现类
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }
}
  1. bean.xml
 	<!--告知spring在创建容器时要扫描的包-->
    <context:component-scan base-package="com.wyj"></context:component-scan>

    <!--配置QueryRunner对象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

—可以根据上面第三部分的内容最后可以将bean.xml完全去除。—

5. spring整合Junit

5.1 问题及分析

在测试类中，每个测试方法都有以下两行代码：

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。
分析：

  1. 应用程序的入口
    main方法
  2. junit单元测试中，没有main方法也能执行
    junit集成了一个main方法
    该方法就会判断当前测试类中哪些方法有 @Test注解
    junit就让有Test注解的方法执行
  3. junit不会管我们是否采用spring框架
    在执行测试方法时，junit根本不知道我们是不是使用了spring框架
    所以也就不会为我们读取配置文件/配置类创建spring核心容器
  4. 由以上三点可知
    当测试方法执行时，没有Ioc容器，就算写了Autowired注解，也无法实现注入

5.2 实现步骤

  1. 导入依赖jar包
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
  1. 使用junit提供的一个注解把原有的main方法替换成spring提供的
    @RunWith
  2. 告知Spring的运行器，spring的ioc创建是基于xml还是注解的，并且说明位置。
    @ContextConfiguration
    Locations:指定xml文件的位置，加上classpath关键字表示在类路径下
    classes：指定注解类所在的位置
  • 当使用spring5.x版本时，要求junit的jar包必须是4.1.2及以上
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations= {"classpath:bean.xml"})
public class AccountServiceTest {
	@Autowired
	private IAccountService as ;
}
乔婧Bluen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springspring基于注解的IOC配置
qq_43814760的博客
04-20 399
spring基于注解的IOC配置 （一）常用注解介绍 1.对象实例化注解（IOC） 如果想要是实现对象实例化，需要在类上面加 @component 该注解的作用 在使用该注解的时候，也可以添加对应的属性： 和@Component注解作用相同的还有三个： @Controller 在表现层使用，标明该类是表现层的类 @Service 在业务层使用，标明该类是业务层的类 @Repository 在持久层使用，标明该类是持久层的类 2.依赖注入注解（ D...
SpringIOC配置详解
xinghuo0007的博客
08-21 969
Spring IOC 本文引用自：https://elfgirl.top/archives/638 spring概述及其特点 (1)概述 1spring是一个开源框架 2spring是为了简化企业级开发而生，可以简单的实现只有EJB才能实现的功能 3spring是一个IOC(DI)和AOP容器框架 (2)...
基于注解的SpringIoc配置
weixin_44293582的博客
12-05 127
基于注解的SpringIoc配置2.4 基于注解的Ioc配置xml与注解的对应取代xml配置文件的注解类Spring整合Junit 2.4 基于注解的Ioc配置 xml与注解的对应 使用注解开发时，bean.xml中的约束与xml配置不同，以下为约束 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http:
Spring——基于注解的IOC配置
紫罗兰与海棠的博客
01-04 176
，，
Spring（三）--基于注解的IOC配置
Apikaqiu的博客
02-18 188
注解配置和 xml 配置要实现的功能都是一样的，都是要降低程序间的耦合。只是配置的形式不一样。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apac
2、Spring基于注解的IOC配置、以及常用注解
yangbo_CSDN的博客
09-11 180
Spring目录1 案例：spring 基于xml的 IoC 的实现2 基于注解的 IOC 配置2.1 明确2.2 环境搭建2.2.1 第⼀步：添加必备 jar 包到⼯程中。2.2.2 第⼆步：使⽤@Component注解配置管理的资源2.2.3 第三步：创建 spring 的 xml 配置⽂件并开启对注解的⽀持2.3 常⽤注解2.3.1 ⽤于创建对象的2.3.1.1 @Component2.3.1.2 @Controller @Service @Repository2.3.2 ⽤于注⼊数据的2.3.2
Spring IOC 注解配置
weixin_41978551的博客
08-11 145
基于XML的IOC配置，创建一个bean时，需要在.xml文件中声明一个bean，然后在main函数中加载该.xml来创建容器 创建bean 在某个类上添加任何一个注解都能快速将这个组件加入ioc容器的管理中： spring有四个注解： @Controller：控制器，推荐给控制器层(servlet包下的这些)的组件加这个注解 @Service：业务逻辑，推荐业务逻辑层的组件加这个注解 @Repository：给数据库层(持久化层,dao层)的组件添加这个注解 @Component：给不属于以上几层的组件添
Spring IOC基于注解启动示例详析
08-26
基于注解启动是 Spring IOC 容器的一种启动方式，通过使用注解来配置和管理 Bean 对象。这种方式可以简化配置文件，提高开发效率和代码可读性。在本文中，我们将通过示例代码详细介绍 Spring IOC 基于注解启动的相关...
基于注解的IOC配置，Spring整合Junit。
11-15
基于注解的IOC配置，Spring整合Junit_特别适合新手学习。
Spring通过注解实现IOC
04-18
在实际应用中，结合Spring的XML配置或者基于Java的配置（@Configuration和@Bean注解），可以构建出复杂的依赖关系图。使用注解实现的IOC使得代码更加简洁，减少了XML配置，提高了开发效率。 总结来说，Spring通过...
Spring常用注解 使用注解来构造IoC容器的方法
08-28
本文将详细介绍 Spring 框架中常用的注解，并阐述如何使用这些注解来构造 IoC 容器。IoC 容器是 Spring 框架的核心组件之一，它提供了一个强大的依赖注入机制，能够帮助开发者更方便地管理和维护应用程序中的组件。...
手写SpringIOC注解实现版本
01-25
这个"手写Spring IOC注解实现版本"项目旨在帮助我们深入理解Spring框架的工作原理，通过实际动手实现来增强对IoC容器和注解驱动编程的理解。 在Spring中，IOC意味着应用程序不再直接创建对象，而是将对象的创建和...
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 936
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
5.SpringBoot核心源码-启动类源码分析
最新发布
流月up的博客
07-12 381
SpringBoot核心源码-启动类源码分析
elk部署springboot
Chihirozy的博客
07-11 326
elk部署springboot。
基于SpringBoot构造超简易QQ邮件服务发送 第二版
键盘爱好者
07-09 269
第二版的更新点是追加了 邮箱附件功能 ( 后期追加定时任务 )
SpringSecurity中文文档（Domain Object Security (ACLs)）
znjy111的博客
07-09 772
本节描述 SpringSecurity 如何使用访问控制列表(ACL)提供域对象安全性。复杂的应用程序通常需要定义超出 Web 请求或方法调用级别的访问权限。相反，安全决策需要包括 who (Authentication)、 where (MethodInvation)和 what (Some DomainObject)。换句话说，授权决策还需要考虑方法调用的实际域对象实例主题。假设您正在为宠物诊所设计一个应用程序。基于 Spring 的应用程序的用户主要有两类: 宠物诊所的工作人员和宠物诊所的客户。
Spring AOP - 自定义注解实现共性需求
weixin_43732943的博客
07-09 318
Spring AOP - 自定义注解实现共性需求
SpringSecurity（Authorization Events）
znjy111的博客
07-09 329
对于每个被拒绝的授权，都会激发一个 AuthorizationDeniedEvent。此外，还可以为授予的授权激发 AuthorizationGrantedEvent。若要侦听这些事件，必须首先发布 AuthorizationEventPublisher。Spring Security 的 SpringAuthorizationEventPublisher 可能会做得很好。
2.SpringIOC-Annotation銆丣unit.pdf
11-08
Spring通过其IoC容器实现这一模式，提供了基于XML和注解两种方式的配置。文档中提到的1.1.1部分可能详细阐述了IoC的基本概念和工作原理。 1.1.2部分则可能详细介绍了如何使用Spring的注解来实现IoC，例如`@...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值