Spring注解

最新推荐文章于 2024-11-17 23:49:21 发布

小熊跃龙

最新推荐文章于 2024-11-17 23:49:21 发布

阅读量122

点赞数 1

文章标签： spring java aop

本文链接：https://blog.csdn.net/weixin_49412498/article/details/116430451

版权

Spring注解

当我们学习Spring之前肯定要知道他的好处是什么？

一.好处

1.方便解耦,简化开发(高内聚低耦合)

Spring就是一个大的工厂(容器),Spring工厂是用来生成bean的,可以将所有创建和依赖关系维护,交给Spring管理

2.AOP编程的支持

Spring提供面向切面编程,可以方便的实现对程序进行权限拦截，运行监控等工功能

3.声明式事务的支持

只需要通过配置就可以完成对事物的管理,无需手动编程代码

4.方便程序测试

Spring对junit4支持(单元测试),可以通过注解方便的测试Spring程序

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架(如:Struts,Hibernate,MyBatis等)的直接支持,方便整合其他框架

6.降低JavaEE API的使用难度(需要学完SpringBoot才能体会到)

Spring对javaEE开发中非常难用的一些API(如:JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

二、解释IOC和AOP

1.什么是IOC?

控制反转其实他不是什么技术 ,而是一种设计思想就是将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制，我们以前是不是需要new去创建对象?现在是不需要的了我们只需要告诉容器我们需要什么？然后容器就会给我们一个这样的对象,从而到达了控制反转,被动的去接收就行了，简单来说ioc就是一个生产和管理bean的容器,要是产生的是单例的bean,他还可以管理bean的生命周期

2.什么是AOP ?

面向切面将程序中的交叉业务逻辑(比如安全,日志,事物等),封装成一个切面,然后注入到目标对象(具体业务逻辑)中去

比如我们需要记录日志就写个记录日志的类然后中间写一些方法，然后在spring.xml里面配置一个bean然后配置aop ,在定义切入点，定义切面,用里面的某一个增强方法，然后就可以实现对该类下所有的方法进行日志打印。

三、Spring常用的注解

1.声明(创建)bean的注解

1.@Repository

2.@Service

3.@Controller

4.@Bean

5.@Configuration

6.@Component

…

2.注入(获取)bean的方式

1.@Autowried

2.@Resource

3.AOP中的注解

1. @Pointcut切入点

2.@Aspect切面

3.增强处理

1.@Before前置

2.@AfterReturning后置

3.@After最终

4.@Around环绕

5.@AfterThrowing异常

四、ioc注解代码块

1.dao包下的impl包下代码

package dao.impl;

import dao.UserDao;
import org.springframework.stereotype.Repository;

/**
 * 将这个类标识成了一个bean,Bean名称默认是类名首字母小写
 * <bean id="userDaoImpl" class="dao.impl.UserDaoImpl"></bean>
 */
@Repository("userDaoImpl")
public class UserDaoImpl implements UserDao {
    /**
     * 添加用户信息
     */
    @Override
    public void addUser() {
        System.out.println("默认方式添加了一个用户");
    }

    /**
     * 删除用户信息
     */
    @Override
    public void delUser() {
        System.out.println("默认方式删除用户信息");
    }
}




package dao.impl;

import dao.UserDao;
import org.springframework.stereotype.Repository;

/**
 * 将这个类标识成了一个bean,Bean名称默认是类名首字母小写
 * <bean id="userDaoImpl" class="dao.impl.UserDaoImpl"></bean>
 */
@Repository(value = "userMySQLDaoImpl")
public class UserMySQLDaoImpl implements UserDao {
    /**
     * 添加用户信息
     */
    @Override
    public void addUser() {
        System.out.println("MySQL方式添加了一个用户");
    }

    /**
     * 删除用户信息
     */
    @Override
    public void delUser() {
        System.out.println("MySQL方式删除用户信息");
    }
}

2.dao包下的代码

package dao;

public interface UserDao {
    /**
     * 添加用户的方法
     */
    void addUser();

    void delUser();
}

3.service包下的impl包下代码

package service.impl;

import dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import service.UserService;

import javax.annotation.Resource;

/**
 * 将这个类标识成了一个bean,Bean名称默认是类名首字母小写
 * <bean id="userServiceImpl" class="service.impl.UserServiceImpl"></bean>
 */
@Service
public class UserServiceImpl implements UserService {
    /**
     * 相当于new一个对象   userDaoImpl
     * @Autowired的作用是将ioc中同类型的bean注入给UserDao对象,为其赋值
     * 现在UserDao有两个子类都是UserDao类型,程序不能识别你将要注入哪一个
     * Qualifier()指定注入类型的Bean名称
     */
//    @Autowired
//    @Qualifier("userDaoImpl")
    @Resource(name = "userDaoImpl")
    private UserDao userDao;

    //如果用这两种方式又要配置xm,又回到了昨天的内容
    //1.set注入
    //2.构造函数注入

    /**
     * 添加用户的方法
     */
    @Override
    public void addUser() {
        userDao.addUser();
    }

    /**
     * 删除用户的方法
     */
    @Override
    public void delUser() {
        userDao.delUser();
    }
}

4.service包下代码

package service;

public interface UserService  {
    /**
     * 添加用户
     */
    void addUser();

    /**
     * 删除用户
     */
    void delUser();
}

5.applicationContext.xm配置

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

<!--    将某些包下的bean扫描到ioc容器中-->
<!--    扫描dao层以及service层所有组件(Bean)-->
        <context:component-scan base-package="dao,service"></context:component-scan>
</beans>

6.log4j文件

log4j.rootLogger=debug, stdout, R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=5

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

7.测试类代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.impl.UserServiceImpl;

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

public class Text {
    public static void main(String[] args) {
        ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取所有定义Bean的名称
//        String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
//        List<String> strings = Arrays.asList(beanDefinitionNames);
//        //为什么会有userDaoImpl这个呢？
//        for (String string : strings) {
//            System.out.println(string);
//        }
        //userDaoImpl
        //userServiceImpl
        UserServiceImpl userDaoImpl =(UserServiceImpl)ioc.getBean("userServiceImpl");
        userDaoImpl.addUser();
    }
}

五、aop注解代码块

1.proxy包下代码

package proxy;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * Aspect开始执行了切面的配置
 * Component也是可以将一个类注册成一个bean的
 */
@Aspect
@Component
public class LogProxy {

    /**
     * @Pointcut用来定义切入点
     * 方法名称就是切入点的名称
     */
    @Pointcut("execution(* service..*.add*(..))")
    public void addpointcut(){

    }
    @Pointcut("execution(* service..*.del*(..))")
    public void delpointcut(){

    }
    /**
     * 在操作之前打印日志
     * 将切入点的表达式绑定到切面上面
     */
    @Before("addpointcut()")
    public void befoer(){
        System.out.println("操作之前打印的日志");
    }

    /**
     *在操作之后打印日志
     */
    @AfterReturning(pointcut = "delpointcut()")
    public void afterReturing(){
        System.out.println("操作之后打印的日志");
    }

    /**
     * 异常增强,只有代码有异常 的时候才会打印这个日志
     */
    @AfterThrowing(pointcut = "addpointcut()",throwing = "e")
    public void myException(Exception e){
        System.out.println("出现异常打印日志"+e);
    }

    /**
     *
     * 最终增强,不管出现日志都会打印日志
     */
    @After("addpointcut()")
    public void after(){
        System.out.println("你看到的是最终增强的日志");
    }

    /**
     * 环绕增强u
     */
    @Around("addpointcut()")
    public void around(ProceedingJoinPoint jp){
        /**
         * getTarget()获取这个类的名称
         * getSignature().getName()获取这个方法的名称
         * jp.getArgs():获取该类中方法参数
         */
        //这个属于前置增强
        System.out.println("调用了"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法的参数是"+ Arrays.toString(jp.getArgs()));
        try {
            //获取方法返回值
            Object proceed = jp.proceed();
            //后置增强
            System.out.println("调用了"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法返回值是"+proceed);
        }catch (Throwable e){
            //异常增强
            System.out.println("异常增强");
            try {
                throw e;
            }catch (Throwable throwable){
                throwable.printStackTrace();
            }
        }finally {
            //最终增强
            System.out.println("最终增强");
        }
    }
}

2.service包下impl包下代码

package service.impl;

import org.springframework.stereotype.Service;
import service.Userservice;
@Service
public class UserServiceImpl implements Userservice {
    @Override
    public void addUser() {
      //  int i=1/0;
        System.out.println("默认增加用户");
    }

    @Override
    public void delUser() {
        System.out.println("默认删除用户");
    }
}

3.service包下代码

package service;

public interface Userservice {
    void addUser();

    void delUser();
}

4.applicationContext.xm配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--    扫描dao层以及service层所有组件(Bean)-->
    <context:component-scan base-package="service,proxy"></context:component-scan>
<!--    开启aop的自定代理配置-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<!--
        0.定义代理类的bean
        1.开始切面配置
        2.定义切入点
        3.定义切面
        4.执行增强配置-->
</beans>

5.log4j文件

log4j.rootLogger=debug, stdout, R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=5

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

6.测试类代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Userservice;

public class Test {
    public static void main(String[] args) {
      ApplicationContext ioc=new ClassPathXmlApplicationContext("applicationContext.xml");
        Userservice userServiceImpl =(Userservice) ioc.getBean("userServiceImpl");
        userServiceImpl.addUser();
      //  userServiceImpl.delUser();
    }
}