Spring注解驱动开发-基础篇

最新推荐文章于 2024-01-23 09:04:21 发布
最新推荐文章于 2024-01-23 09:04:21 发布
阅读量253 收藏 1
点赞数 1
分类专栏： Spring 文章标签： Spring 注解 SpringBoot Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juntian2008/article/details/87510147
版权

一、IOC部分

1. 以往在使用Spring时，采用Java代码加上xml配置文件的方式

AbstractXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:smart.spring.xml");

随着SpringBoot的兴起，开始大量采用注解的方式来配置IOC容器和装配Bean，这样就可以不再维护xml配置文件了，但对开发人员的技能有了更高的要求
学习一些常用的Spring注解，才能跟上Spring开发使用的步伐

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationConfig.class);

开发中常用的注解有@Controller，@Service，@Component，@Repository...

2. @Configuration注解告诉Spring这是一个配置类，相当于Spring的一个xml配置文件，我们可以在其中定义Bean信息，修改IOC容器配置等
@Configuration
public class ApplicationConfig
{
}

3. @Bean给容器中注册一个Bean，Id默认使用方法名，Bean类型为方法的返回值类型，可通过注解的name或value属性修改Id名称，
通过initMethod和destroyMethod属性来指定初始化和销毁方法

@Configuration
public class ApplicationConfig
{
    @Bean(name = "user")
    public User user()
    {
        return new User("RealJt", 20);
    }
}

4. @ComponentScan包扫描，下面为Web环境经典的包扫描配置方式
4.1 使用excludeFilters排除
@Configuration
@ComponentScan(value = "com.realjt.smart", excludeFilters = {
        @Filter(type = FilterType.ANNOTATION, classes = { Controller.class, ControllerAdvice.class }) })
public class ApplicationConfig
{
}

4.2 使用includeFilters包含，默认useDefaultFilters=true，即扫描加载所有Bean定义注解，若需要只包含配置的过滤器结果，
需要配置useDefaultFilters=false
@Configuration
@ComponentScan(value = "com.realjt.smart", useDefaultFilters = false, includeFilters = {
        @Filter(type = FilterType.ANNOTATION, classes = { Controller.class, ControllerAdvice.class }) })
public class WebApplicationConfig
{
}

4.3 FilterType的取值类型
FilterType.ANNOTATION 按照注解类型
FilterType.ASSIGNABLE_TYPE 按照具体的类型
FilterType.ASPECTJ 使用ASPECTJ表达式
FilterType.REGEX 使用正则表达式
FilterType.CUSTOM 自定义规则，必须是TypeFilter的实现类

4.4 FilterType.CUSTOM自定义过滤规则，class的值必须是TypeFilter的实现类
public class SmartTypeFilter implements TypeFilter
{
    /**
     * @param metadataReader
     *            读取到的当前正在被扫描类的信息
     * @param metadataReaderFactory
     *            可以获取到其他任何类信息
     * @return 是否添加到容器中
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException
    {
        // 获取当前正在被扫描处理的类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前正在被扫描处理的类的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前类资源(类的路径)
        Resource resource = metadataReader.getResource();
        // 获取当前正在被扫描处理的类名称
        String className = classMetadata.getClassName();

        return true;
    }
}

5. @Scope作用域
ConfigurableBeanFactory.SCOPE_SINGLETON 默认是单实例的，容器启动时就调用方法创建对象，后面每次从容器中获取的都是同一个对象
ConfigurableBeanFactory.SCOPE_PROTOTYPE 多实例的，每次获取的时候都会调用方法创建一个对象
WebApplicationContext.SCOPE_REQUEST Web环境，一个请求一个实例
WebApplicationContext.SCOPE_SESSION Web环境，一个会话一个实例

@Configuration
public class ApplicationConfig
{
    @Bean(name = "user")
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public User user()
    {
        return new User("RealJt", 20);
    }
}

6. @Lazy懒加载
加Lazy注解的单实例Bean在容器启动的时候并不会创建对象，而是在首次获取该对象时才调用方法创建对象

@Configuration
public class ApplicationConfig
{
    @Bean(name = "user")
    @Lazy
    public User user()
    {
        return new User("RealJt", 20);
    }
}

7. @Conditional按照条件添加组件，value值为Condition的实现类
@Conditional也可以放在类上，满足条件时类中定义的Bean才会向容器中注册
@Configuration
public class ApplicationConfig
{
    /**
    * 如果WindowsCondition类的matches返回true,则向容器中添加该组件
    */
    @Bean(name = "user")
    @Conditional(value = { WindowsCondition.class })
    public User user()
    {
        return new User("Bill Gates", 50);
    }
}

public class WindowsCondition implements Condition
{
    /**
     * @param context
     *            判断条件能使用的上下文
     * @param metadata
     *            注解信息
     * @return 是否匹配,配置则向容器中添加组件
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata)
    {
        // 能获取到容器使用的BeanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 获取到类加载器
        ClassLoader classLoader = context.getClassLoader();
        // 获取到环境信息
        Environment environment = context.getEnvironment();
        // 获取到Bean定义信息
        BeanDefinitionRegistry registry = context.getRegistry();

        String osName = environment.getProperty("os.name");
        if (osName.contains("Windows"))
        {
            return true;
        }

        return false;
    }
}

8. @Import向容器中注册组件

8.1 向容器中导入一个User对象，Id默认是User类的全类名
@Configuration
@Import(value = { User.class })
public class ApplicationConfig
{
}

8.2 使用ImportSelector添加组件，自定义类实现ImportSelector接口
// 向容器中添加多个组件
@Configuration
@Import(value = { User.class, SmartImportSelector.class })
public class ApplicationConfig
{
}

public class SmartImportSelector implements ImportSelector
{
    /**
     * @param importingClassMetadata
     *            当前标注@Import注解的类的所有注解信息
     * @return 返回需要导入组件的全类名数组,可以返回空数组,不能返回null
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata)
    {
        return new String[] { "com.realjt.domain.Blue", "com.realjt.domain.Red" };
    }
}

8.3 使用ImportBeanDefinitionRegistrar注册组件
// 向容器中添加多个组件
@Configuration
@Import(value = { User.class, SmartImportSelector.class, SmartImportBeanDefinitionRegistrar.class })
public class ApplicationConfig
{
}

public class SmartImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar
{
    /**
     * @param importingClassMetadata
     *            当前类的注解信息
     * @param registry
     *            所有Bean的注册信息
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry)
    {
        // 可以判断需要的组件是否已注册
        if (registry.containsBeanDefinition("com.realjt.domain.Red"))
        {
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Yellow.class);
            // 向容器中注册一个Yellow类的定义信息
            registry.registerBeanDefinition("com.realjt.domain.Yellow", rootBeanDefinition);
        }
    }
}

9. 使用FactoryBean，例如注册数据源时的密码解密操作
@Configuration
public class ApplicationConfig
{
    @Bean
    public DataSourcePasswordFactoryBean password(@Value("${jdbc.password}") String password)
    {
        // 密码密文从配置文件中读取,并向容器中返回注册密码明文
        DataSourcePasswordFactoryBean dataSourcePasswordFactoryBean = new DataSourcePasswordFactoryBean();
        dataSourcePasswordFactoryBean.setPassword(password);

        return dataSourcePasswordFactoryBean;
    }

    @Bean
    public DataSource dataSource(String password)
    {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setPassword(password);

        return dataSource;
    }
}

public class DataSourcePasswordFactoryBean implements FactoryBean<String>
{
    private String password;

    /**
     * 得到对象
     */
    @Override
    public String getObject() throws Exception
    {
        // 这里返回之前可以做解密
        return password;
    }

    /**
     * 对象类型
     */
    @Override
    public Class<?> getObjectType()
    {
        return String.class;
    }

    /**
     * 是否是单例
     */
    @Override
    public boolean isSingleton()
    {
        return true;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }
}

延伸:applicationContext.getBean("&password");可以得到工厂Bean本身,即DataSourcePasswordFactoryBean类对象
而不是DataSourcePasswordFactoryBean的泛型类对象

10. Bean的生命周期

10.1 配置initMethod和destroyMethod
在容器启动时先创建对象，给对象属性赋值，然后执行initMethod
在容器关闭时执行destroyMethod，但是配置为prototype的对象不会执行destroyMethod，因为容器并不会管理这个对象
@Configuration
public class ApplicationConfig
{
    /**
     * 初始化和销毁方法不能有参数
     */
    @Bean(value = "car", initMethod = "init", destroyMethod = "destroy")
    public Car car()
    {
        return new Car();
    }
}

public class Car
{
    public Car()
    {
    }

    public void init()
    {
    }

    public void destroy()
    {
    }
}

10.2 实现InitializingBean和DisposableBean接口
@Configuration
public class ApplicationConfig
{
    @Bean(value = "car")
    public Car car()
    {
        return new Car();
    }
}

public class Car implements InitializingBean, DisposableBean
{
    public Car()
    {
    }

    /**
     * 在对象创建完成,属性赋值后调用
     */
    @Override
    public void afterPropertiesSet() throws Exception
    {
    }

    /**
     * 在对象被销毁时调用
     */
    @Override
    public void destroy() throws Exception
    {
    }
}

10.3 使用@PostConstruct和@PreDestroy注解(JSR250)
public class Car
{
    public Car()
    {
    }

    /**
     * 对象装配完成后调用
     */
    @PostConstruct
    public void init()
    {
    }

    /**
     * 在容器中被销毁对象时调用
     */
    @PreDestroy
    public void destroy()
    {
    }
}

10.4 BeanPostProcessor后置处理器

@Component
public class SmartBeanPostProcessor implements BeanPostProcessor
{
    /**
     * 在对象执行初始化方法之前调用
     * 
     * @param bean
     *            Bean对象
     * @param beanName
     *            Bean名称
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
    {
        // 在这里可以对bean进行包装或替换,再返回
        return bean;
    }

    /**
     * 在对象执行初始化方法之后调用
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
    {
        return bean;
    }
}

11. @Value注解
字面值 @Value("")
SpEl @Value("#{}")
引用外部值 @Value("${}")

12. @PropertySource注解，用于引入外部配置文件
@Configuration
@PropertySource(value = { "classpath:main.properties" }, encoding = "UTF-8", ignoreResourceNotFound = true)
public class ApplicationConfig
{
    @Bean(value = "car")
    public Car car(@Value("${brand}") String brand)
    {
        return new Car(brand);
    }
}

实际应用中也可以通过ConfigurableEnvironment来获取引入的配置信息
ConfigurableEnvironment environment = applicationContext.getEnvironment();
environment.getProperty("brand");

13. @Autowired自动装配，可放在属性上，也可以放在set方法，构造方法，参数上，可通过required设置是否是必须的
优先安装类型匹配查找，如果查找到多个相同类型的组件，再通过属性名作为Id查找
可结合@Qualifier注解明确指定要装配的组件
@Service
public class UserService
{
    @Autowired(required = true)
    public UserDao userDao;
}

@Service
public class UserService
{
    @Autowired
    @Qualifier("userDao")
    public UserDao userDao;
}

容器中有多个相同类型的组件时，可以通过@Primary组件来设置该组件优先被装配
@Configuration
public class ApplicationConfig
{
    /**
     * 当容器中有多个Car类型的组件时，使用@Autowired注入Car类型的组件且没有使用@Qualifier明确指定装配Id时，优先装配这个Car
     */
    @Primary
    @Bean(value = "car")
    public Car car()
    {
        return new Car();
    }
}

14. Spring还支持@Resource(JSR250规范)和@Inject(JSR330规范)注解
14.1 @Resource默认使用名称匹配装配，可以通过name值来指定装配的组件，但不支持@Primary和required = true/false特性

@Service
public class UserService
{
    @Resource(name = "userDao")
    public UserDao userDao;
}

14.2 @Inject和@Autowired一样，但是不能配置required = true/false
需要以下导入jar包才能支持
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

15. Aware接口
ApplicationContextAware
BeanFactoryAware
BeanNameAware
EmbeddedValueResolverAware
EnvironmentAware
MessageSourceAware

16. @Profile指定在哪种环境下注入特定的组件，其value值默认default，具有排他性
@Profile也可放在类上

@Configuration
public class ApplicationConfig
{
    @Bean("develop")
    public DataSource dataSource(String password)
    {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        return dataSource;
    }

    @Bean("test")
    public DataSource dataSource(String password)
    {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        return dataSource;
    }
}

可通过启动参数指定profile的值-Dspring.profiles.active=develop
或通过代码方式切换profile的值，并且可以同时设置多个profile值
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationConfig.class);
applicationContext.getEnvironment().setActiveProfiles("develop", "test");
applicationContext.register(ApplicationConfig.class);
applicationContext.refresh();


二、AOP部分
在程序运行期间将某段代码切入到指定方法的指定位置并运行的编程方式
需要使用@EnableAspectJAutoProxy开启支持AOP注解

@Configuration
@EnableAspectJAutoProxy
public class ApplicationConfig
{
}

经典的日志切面
@Repository
public class Calculator
{
    public int add(int i, int j)
    {
        return i + j;
    }

    public int sub(int i, int j)
    {
        return i - j;
    }

    public int multi(int i, int j)
    {
        return i * j;
    }

    public int div(int i, int j)
    {
        return i / j;
    }
}

@Component
@Aspect
public class LogAspect
{
    /**
     * 切点表达式
     */
    @Pointcut("execution(com.realjt.spring.annotation.dao.Calculator.*(..))")
    public void pointCut()
    {
    }

    /**
     * 前置通知,在目标方法执行前执行
     */
    @Before("pointCut()")
    public void before(JoinPoint joinPoint)
    {
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());

        System.out.println("Before method = " + methodName + ", args = " + args);
    }

    /**
     * 后置通知,在目标方法执行后执行,无论是否发生异常
     */
    @After("pointCut()")
    public void after(JoinPoint joinPoint)
    {
        String methodName = joinPoint.getSignature().getName();

        System.out.println("After method = " + methodName);
    }

    /**
     * 返回通知,在目标方法正常执行返回后执行,可以得到返回值
     */
    @AfterReturning(value = "pointCut()", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result)
    {
        String methodName = joinPoint.getSignature().getName();

        System.out.println("AfterReturning method = " + methodName + ", result = " + result);
    }

    /**
     * 异常通知,在目标方法执行发生异常后执行
     */
    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint, Exception exception)
    {
        String methodName = joinPoint.getSignature().getName();

        System.out.println("AfterThrowing method = " + methodName + ", exception = " + exception);
    }

    /**
     * 环绕通知,手动推进目标方法执行,并处理异常
     */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable
    {
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());

        Object result = null;
        try
        {
            // 前置通知
            System.out.println("Before method = " + methodName + ", args = " + args);

            result = joinPoint.proceed();

            // 返回通知
            System.out.println("AfterReturning method = " + methodName + ", result = " + result);
        }
        catch (Throwable e)
        {
            // 异常通知,这里需要决定异常是吞掉还是继续向上抛出
            System.out.println("AfterThrowing method = " + methodName + ", exception = " + e);

            throw e;
        }
        finally
        {
            // 后置通知
            System.out.println("After method = " + methodName);
        }

        return result;
    }
}

三、声明式事务
需要用@EnableTransactionManagement注解开启支持事务
@Configuration
@EnableTransactionManagement
public class ApplicationConfig
{
    /**
     * 数据源配置
     */
    @Bean
    public DataSource dataSource() throws Exception
    {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        dataSource.setDriverClass("");
        dataSource.setJdbcUrl("");
        dataSource.setUser("");
        dataSource.setPassword("");

        return dataSource;
    }

    /**
     * 事务管理器
     */
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource)
    {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);

        return transactionManager;
    }
}

在需要事务的方法上添加@Transactional注解
主要参数
transactionManager 指定事务管理器
propagation 事务传播行为，当事务方法被另一个事务方法调用时，指定事务的应该如何传播，例如是维持在现有事务中执行还是新开启一个事务
isolation 事务隔离级别
timeout 超时时间
readOnly 是否只读
rollbackFor 针对哪些异常进行回滚
noRollbackFor 针对哪些异常不进行回滚

propagation 事务传播行为
Propagation.REQUIRED 默认值，已有事务，则在这个事务中运行，否则新开一个事务继续运行
Propagation.REQUIRES_NEW 必须新开启一个事务，并在这个新开启的事务中运行
Propagation.SUPPORTS 如果有事务则运行则事务中，否则可以不在事务中运行
Propagation.NOT_SUPPORTED 此方法不应该在事务中运行，如果有事务，则将该事务挂起
Propagation.MANDATORY 此方法必须运行在事务中，如果没有事务，则抛出异常
Propagation.NEVER 此方法不应该运行在事务中，如果有事务，则抛出异常
Propagation.NESTED 如果有事务，就在这个事务的嵌套事务内运行，否则就新开启一个事务，并在这个新开启的事务中运行

数据库并发问题
脏读
Session_1 将某条数据的age值从20改成了30
Session_2 读取了Session_1更新后的值30
Session_1 回滚，age值恢复到了20
Session_2 读取到的30是一个无效的值

不可重复读
Session_1 读取了某条数据的age值为20
Session_2 将age值修改为30
Session_1 再次读取age值为30，两次读取的值不一样

幻读
Session_1 读取了USER表中的一部分数据
Session_2 向USER表中插入了新的行
Session_1 再次读取USER表时，多了一些行

事务隔离级别
1.读未提交
2.读已提交
3.可重复读
4.串行化

隔离级别脏读不看重复读幻读
Read UnCommitted有有有
Read Committed无有有
Repeatable Read无无有
Serializable无无无
隔离级别OracleMySql
Read UnCommitted不支持支持
Read Committed支持(默认)支持
Repeatable Read不支持支持(默认)
Serializable支持支持

isolation 事务隔离级别
Isolation.DEFAULT
Isolation.READ_UNCOMMITTED
Isolation.READ_COMMITTED
Isolation.REPEATABLE_READ
Isolation.SERIALIZABLE


四、Spring扩展
1. BeanPostProcessor 在Bean初始化前后进行拦截工作

@Component
public class SmartBeanPostProcessor implements BeanPostProcessor
{
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
    {
        // 在执行Bean初始化方法前执行
        // 这里可以修改Bean实例的属性
        // 也可以新初始化任何类型的实例返回，从而实现替换已有实例
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
    {
        // 在执行Bean初始化方法后执行
        // 这里可以修改Bean实例的属性
        // 也可以新初始化任何类型的实例返回，从而实现替换已有实例
        return bean;
    }
}

2. BeanFactoryPostProcessor 在BeanFactory标准初始化后执行postProcessBeanFactory方法工作，
所有的Bean定义信息已经加载到beanFactory中，但所有Bean的实例还未创建

@Component
public class SmartBeanFactoryPostProcessor implements BeanFactoryPostProcessor
{
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
        // 得到Bean定义信息数量
        int count = beanFactory.getBeanDefinitionCount();
        // 得到所有Bean定义的名字
        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
    }
}

3. BeanDefinitionRegistryPostProcessor 为BeanFactoryPostProcessor的子接口，postProcessBeanDefinitionRegistry方法在Bean定义信息
将要被加载时执行，此时Bean实例还未创建，先于postProcessBeanFactory方法执行，方法参数BeanDefinitionRegistry对象为Bean定义的存储中心，
BeanFactory就是按照BeanDefinitionRegistry中保存的Bean定义信息来创建Bean实例的

@Component
public class SmartBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor
{
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException
    {
        // Bean定义数量
        int count = registry.getBeanDefinitionCount();
        
        // 注册一个Bean定义信息
        RootBeanDefinition beanDefinition = new RootBeanDefinition(User.class);
        registry.registerBeanDefinition("user", beanDefinition);
        // 移除一个Bean定义信息
        registry.removeBeanDefinition("user");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {

    }
}

4. ApplicationListener 应用监听器，通过回调方式监听Spring IOC容器中发布的事件，泛型为要监听的事件类型，
4.1 实现ApplicationEvent接口
例如ContextRefreshedEvent为容器启动完成事件，ContextClosedEvent为容器关闭事件
可以通过AbstractApplicationContext.publishEvent(ApplicationEvent)来发布一个自定义事件

@Component
public class SmartApplicationListener implements ApplicationListener<ApplicationEvent>
{
    @Override
    public void onApplicationEvent(ApplicationEvent event)
    {
        // 收到事件
    }
}

4.2 使用@EventListener注解
@Service
public class UserService
{
    @EventListener(classes = { ApplicationEvent.class })
    public void listen(ApplicationEvent event)
    {
        // 收到事件
    }
}

RealJt
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring注解驱动开发
weixin_52055811的博客
01-08 692
Spring注解驱动开发
Spring Boot Web 开发注解篇
08-29
在 Spring Boot 中，`spring-boot-starter-web` 是一个核心依赖，它极大地简化了Web应用的开发过程。...通过注解驱动的编程方式，开发者能够更专注于业务逻辑，而不是底层的配置和设置，从而提高了开发效率。
8.spring系列- java注解
qq_32062699的博客
09-24 2440
问题 注解是干什么的？ 一个注解可以使用多次吗？如何使用？ @Inherited是做什么的？ @Target中的TYPE_PARAMETER和TYPE_USER用在什么地方？ 泛型中如何使用注解？ 注解定义可以实现继承吗？ spring对注解有哪些增强？@Aliasfor注解是干什么的？ 什么是注解 代码中注释大家都熟悉吧，注释是给开发者看的，可以提升代码的可读性和可维护性，但是对于java编译器和虚拟机来说是没有意义的，编译之后的字节码文件中是没有注释信息的；而注解和注释有点类似，唯一的区别就是注释是
java的@Inject注解
最新发布
听海边涛声
01-23 756
java的@Inject注解
@autowired注解_你真的了解 Spring 框架中的注解注入吗
weixin_39842937的博客
11-23 411
1. 前言@Resource和@Autowired注解都可以在Spring Framework应用中进行声明式的依赖注入。而且面试中经常涉及到这两个注解的知识点。今天我们来总结一下它们。2. @Resource全称javax.annotation.Resource,它属于JSR-250规范的一个注解，包含Jakarta EE(J2EE)中。Spring提供了对该注解的支持。我们来详细了解一下该注解...
Android @Inject(注入)
做最好的自己
09-17 1万+
@Inject     @Inject支持构造函数、方法和字段注解，也可能使用于静态实例成员。可注解成员可以是任意修饰符（private,package-private,protected,public）。注入顺序：构造函数、字段，然后是方法。父类的字段和方法注入优先于子类的字段和方法，同一类中的字段和方法是没有顺序的。     @Inject注解的构造函数可以是无参或多个参数的构造函数。@I...
spring-framework-4.3.29.RELEASE.zip
05-25
- **测试支持**：Spring提供了丰富的测试工具和API，包括单元测试、集成测试和端到端测试，方便进行测试驱动开发。 3. **新特性与改进** - **Java 8支持**：4.3版本全面支持Java 8，包括Lambda表达式和新的日期...
Spring Boot 入门 - 基础篇（11）- 数据源配置
04-30
在本篇“Spring Boot入门 - 基础篇（11）- 数据源配置”中，我们将探讨如何在Spring Boot项目中配置数据源，以便连接到数据库并执行相关的CRUD操作。Spring Boot以其自动化配置和简化开发流程而受到广泛欢迎，它使得...
spring-5.3.14-schema.zip
01-07
此外，Spring MVC还支持注解驱动，简化了配置，使得开发更加灵活高效。 2. **beans** Spring的核心在于IoC（Inversion of Control）容器，它管理着应用对象的生命周期和依赖关系。Beans模块是Spring的基础，定义了...
Spring-Demo-1.zip
07-22
通过这个"Spring-Demo-1"示例，开发者不仅能学习到Spring框架的基础知识，还能了解到如何将这些知识应用到实际项目中，从而提升自己的开发技能。记住，实践是检验真理的唯一标准，动手尝试并理解每一个环节，是掌握...
spring注解驱动
07-11
spring注解驱动spring注解驱动spring注解驱动spring注解驱动
JAVA学习日记: 注解(5)
SIESTA030的博客
10-14 233
今天学习了的主要内容： 1.什么是注解处理器 2.如何使用其来读取信息 注解处理器： 注解处理器能够在程序运行期间将代码中的一些使用注解的信息运用反射机制来得到它，值得一提的是，注解它本身不会影响编译。 注解处理器的使用前提： 该注解有@Retention(RetentionPolicy.RUNTIME) 上代码！ Test类（主测试类）: package LessonForAnnotation05; import java.lang.reflect.InvocationTargetEx
Spring注解驱动开发-事务原理：声明式事务
Choco1ove的博客
02-07 226
声明式事务： 环境搭建： 1、导入相关依赖 数据源、数据库驱动、Spring-jdbc模块 2、配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据 3、给方法上标注@Transactional表示当前方法是一个事务方法； 4、@EnableTransactionManagement开启基于注解的事务管理功能；@EnableXXX 5、配置事务管理器来控制事务; @Bean public PlatformTransactionManagertransactio.
Spring注解驱动开发及源码解析
freellf的专栏
09-23 448
对spring注解进行开发及源码进行解析，
Spring注解驱动
从基础到源码解析的学习记录
11-08 491
文章目录一、组件注册1、@Scope设置组件作用域2、@Lazy懒加载3、@Conditional按照条件加载bean4、@Import为容器添加组件1）@Import2）@ImprotSelector3）@ImprotBeanDefinitionRegistrar 一、组件注册 1、@Scope设置组件作用域 prototype：多例，ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象。 singleton：单例（默认值），ioc容器启动会调用方法创建对象方到容器中。每
【Java】Spring注解驱动开发
雨下一整晚real的博客
08-31 348
一、配置注解 首先进行一个注解案例的开发：创建数据库，然后创建JdbcTemplate对象，对数据库进行插入数据的操作。 一、创建数据库对象 create database spring_ioc; use spring_ioc; create table account{ id int primary key auto_increment, name varchar(50), money double(7,2), } 二、创建一个Maven工程，导入下面的依赖jar包 <dependen
史上最全的java spring注解，没有之一
热门推荐
陈袁的博客
05-27 5万+
注解是个好东西，但好东西我们也是看见过，整理过，理解过，用过才知道好。不求我们每个都记住，但求保有印象，在需要的时候能提取出来再查找相关资料，平时工作就不会显得那么被动了。1.@Configuration注解该类等价 与XML中配置beans，相当于Ioc容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean，与xml中配置的bean意思一样。@Configurati...
java开启注解驱动怎么做_Spring注解驱动第一讲
weixin_39928768的博客
02-28 149
第一步:创建一个mvn工程,并在pom文件中引入如下版本的Spring-contextorg.springframeworkspring-context4.3.12.RELEASE第二步:在所创建的项目中创建配置类,使用@Configuration注解标识,即为配置类.在配置类中,填写获取bean的方法,方法的返回值为获取的bean类型,方法名即为bean在容器中的名字.代码如下:@Configu...
spring源码分析(一)——bean的注册
青春季风暴
10-24 371
  1、从容器中获取bean的两种方式 a、xml注册获取 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); Person bean = (Person) applicationContext.getBean("person"); System.out.print...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值