复习Spring aop ioc_corp类作为目标类,在corp类中添加方法addworker(employeeemp)作为实现ao-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_60465411/article/details/128764596

创建User 实体类

实体类代码：

package com.bdqn.entity;

public class User {
    private int id;
    private String uname;
    private int age;
    private String address;

    public int getId() {
        return id;
    }

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

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

我们创建IUserDao 接口

接口代码：

package com.bdqn.dao;

import com.bdqn.entity.User;

public interface IUserDao {
    int insertUser(User user);

}

创建UserDaoimpl 实现

实现代码:

package com.bdqn.dao.impl;

import com.bdqn.dao.IUserDao;
import com.bdqn.entity.User;

public class UserDaoImpl implements IUserDao {
    @Override
    public int insertUser(User user) {
        System.out.println("新增方法insertUser  （userDao层） 连接IUserDao接口");
        return 1;
    }
}

创建Service 接口

IUService

package com.bdqn.service;

import com.bdqn.entity.User;

public interface IUService {
    boolean saveUser(User user);
}

创建UserServiceImpl

package com.bdqn.service.impl;

import com.bdqn.dao.IUserDao;
import com.bdqn.dao.impl.UserDaoFactory;
import com.bdqn.dao.impl.UserDaoImpl;
import com.bdqn.entity.User;
import com.bdqn.service.IUService;

public class UserServiceImpl implements IUService {
    IUserDao iUserDao=new UserDaoImpl();

    /**
     * 这里是业务实现层 如果我们使用 IUserDao iUserDao=new UserDaoImpl(); 他会增加接口的运行 而且我们如果需要别的接口还要更改Service如过我们使用
     *
     *     private IUserDao iUserDao= UserDaoFactory.getInstance();
     *
     *     调用接口IuDao接口 实现到UserDaoFactory 调用里面的方法getInstance（）我们在getInstance（）方法里面
     * 
     *     直接 return new OracleDaoImpl(); 获取 OracleDaoImpl(); 不需要动任何代码只需要在UserDaoFactory里面动代码就行
     *
     */
    @Override
    public boolean saveUser(User user) {
        boolean flag =false;
        user.setId(1001);
        if (iUserDao.insertUser(user)>0){
            System.out.println(" 新增的方法Service层   (实现UserServiceImpl实现类)  连接》》UserDaoFactory.getInstance()方法 ");
            return true;
        }
        return flag;
    }
}

编写测试类

test

package com.bdqn.test;

import com.bdqn.entity.User;
import com.bdqn.service.IUService;
import com.bdqn.service.impl.UserServiceImpl;
import org.junit.Test;

public class test {
    @Test
     public void test01() {
        IUService iuService=new UserServiceImpl();
        User user=new User();
        user.setId(1001);
        user.setAddress("ZhaoGuang");
        user.setAge(18);
        user.setUname("Wang");
        if (iuService.saveUser(user)){
            System.out.println("新增成功");
        }else {
            System.out.println("新增失败");
        }
    }
}

运行结果

大家注意如果我们有很多个接口和很多个实现我们难道要创建很多service层吗
IUserDao iUserDao=new UserDaoImpl();
我们使用这个引用，我们可不可以创建一个工厂然后把我们的好多实现放到我们的工厂里面我们直接调用工厂去拿到我们的实现类

下面我们使用工厂方法实现

我们创建一个OracleDaolmpl 实现类实现我们的接口输出一句话

我们创建一个实现类叫做：UserDaoFactory 我们在UserDaoFactory里面创建一个静态的方法

返回我们的OracleDaolmpl 实现类

我们在UsersServiceImpl 调用我们就改成

private IUserDao iUserDao= UserDaoFactory.getInstance();

接口等于我们工厂里面的方法

代码如下

UserServicelmpl:

package com.bdqn.service.impl;

import com.bdqn.dao.IUserDao;
import com.bdqn.dao.impl.UserDaoFactory;
import com.bdqn.dao.impl.UserDaoImpl;
import com.bdqn.entity.User;
import com.bdqn.service.IUService;

public class UserServiceImpl implements IUService {
   // IUserDao iUserDao=new UserDaoImpl();

    /**
     * 这里是业务实现层 如果我们使用 IUserDao iUserDao=new UserDaoImpl(); 他会增加接口的运行 而且我们如果需要别的接口还要更改Service如过我们使用
     *
     *     private IUserDao iUserDao= UserDaoFactory.getInstance();
     *
     *     调用接口IuDao接口 实现到UserDaoFactory 调用里面的方法getInstance（）我们在getInstance（）方法里面
     *
     *     直接 return new OracleDaoImpl(); 获取 OracleDaoImpl(); 不需要动任何代码只需要在UserDaoFactory里面动代码就行
     *
     */
    private IUserDao iUserDao= UserDaoFactory.getInstance();
    @Override
    public boolean saveUser(User user) {
        boolean flag =false;
        user.setId(1001);
        if (iUserDao.insertUser(user)>0){
            System.out.println(" 新增的方法Service层   (实现UserServiceImpl实现类)  连接》》UserDaoFactory.getInstance()方法 ");
            return true ;
        }
        return flag;
    }
}

OracleDaoImpl:

package com.bdqn.dao.impl;

import com.bdqn.dao.IUserDao;
import com.bdqn.entity.User;

public class OracleDaoImpl implements IUserDao {
    @Override
    public int insertUser(User user) {
        System.out.println("OracleDao >>>> insertUser 添加    Oracle数据库");
        return 1;
    }
}

UserDaoFactory:

package com.bdqn.dao.impl;

import com.bdqn.dao.IUserDao;

public class UserDaoFactory {
    public  static IUserDao getInstance(){
    return new OracleDaoImpl();
    }
}

测试

如果想要更大的变化我们这样还是不行的我们String 提供另一个IOC 解决了这个问题

创建HelloString

package com.zhao.entity;

public class HelloSpring {
private  String hello=null;
public  void print(){
    System.out.println("hello值是"+this.hello);
}

    public String getHello() {
        return hello;
    }

    public void setHello(String hello) {
        this.hello = hello;
    }
}

我们首先创建一个resources 下面创建一个applicaticonContext.xml

我们使用bean new HelloString

给setHELLO赋值

<?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-3.2.xsd">
<!--
通过bean元素声明需要spring创建的实例，实例通过class属性指定，并且通过id属性为实例
-->
	<!--
	<bean id="helloSpring" class="com.zhao.entity.HelloSpring">、
	就是HelloSpring helloSpring =new HelloSpring();
	-->
	<bean id="helloSpring" class="com.zhao.entity.HelloSpring">
		<!--
		property元素为实例helloSpring属性赋值，对象调用setHello给属性赋值
		-->
		<property name="hello">
			<value>
				spring
			</value>
		</property>
	</bean>
</beans>

测试类

package com.zhao.test;

import com.zhao.entity.HelloSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    public static void main(String[] args) {
        //读取配置文件，得到helloSpring对象，调用print方法，输出内容
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloSpring hs=(HelloSpring) context.getBean("helloSpring");//读取核心配置文件，得到实例化对象helloSpring
        hs.print();//使用对象调用方法
    }
}

读取配置文件定以的

<bean id="helloSpring" class="com.zhao.entity.HelloSpring">

并调用方法输出

使用配置文件

创建dao接口

    int insert (User user);

创建实现类

    @Override
    public int insert(User user) {
        System.out.println("dao层insertUser方法执行");
        return 1;
    }
}

创建service

boolean saveUser(User user);

创建service实体类

package com.zhao.service;

import com.zhao.dao.IUserDao;
import com.zhao.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;


public class UserServiceImpl implements IUserService {

    public UserServiceImpl(IUserDao userDao){
        this.userDao=userDao;
    }
   public IUserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(IUserDao userDao) {
        userDao = userDao;
    }
    
    @Override
    public boolean saveUser(User user) {
        if (userDao.insert(user)>0){
            System.out.println("业务层saveUser方法执行");
            return true;
        }else {
            return false;
        }

    }
}

使用配置文件

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



	<bean id="UserDao" class="com.zhao.dao.UserDaoImpl"/>
	<!--依赖注入-->
	<bean id="UserService" class="com.zhao.service.UserServiceImpl">
		<property name="UserDao" ref="UserDao"/>
	</bean>
</beans>

测试类

package com.zhao.test;

import com.zhao.entity.User;
import com.zhao.service.IUserService;
import com.zhao.service.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    @Test
    public  void  test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext-bf.xml");
        IUserService userService= (IUserService) context.getBean("UserService");
        User user=new User();
        user.setUname("赵光远");
        user.setId(1);
        if( userService.saveUser(user)){
            System.out.println("保存成功");
        }else {
            System.out.println("保存失败");
        }

        if (userService.delUser(1)){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }

/*       User u=(User) context.getBean("user");
        System.out.println(u.getUname()+u.getAddress());*/
    }
}

aop注解

创建dao层接口

package com.zhao.dao;

import com.zhao.entity.User;

//ioc
public interface IUserDao {
    int insert (User user);


    int delete (int id);
}

创建dao 实现类

package com.zhao.dao;

import com.zhao.entity.User;
import org.springframework.stereotype.Component;

@Component("userDao")
public class UserDaoImpl implements IUserDao {
    @Override
    public int delete(int id) {
        System.out.println("dao层delete方法执行");
        return 1;
    }

    @Override
    public int insert(User user) {
        System.out.println("dao层insertUser方法执行");
        return 1;
    }
}

创建 Service 层接口

package com.zhao.service;

import com.zhao.entity.User;

public interface IUserService {
    boolean saveUser(User user);
    boolean  delUser(int id);
}

Service 实现类

package com.zhao.service;

import com.zhao.dao.IUserDao;
import com.zhao.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service("UserService")
public class UserServiceImpl implements IUserService {
    @Autowired //按类型自动装配
    @Qualifier("userDao") //按照名称装配
            //Java标准 ：@Resource   @Resource("userDao")
    IUserDao userDao;
//无参构造函数
    public  UserServiceImpl(){}

//有参构造函数
    public UserServiceImpl(IUserDao userDao){
        this.userDao=userDao;
    }
   public IUserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(IUserDao userDao) {
        userDao = userDao;
    }

    @Override
    public boolean delUser(int id) {
        if (userDao.delete(id)>0){
            System.out.println("业务层delete方法执行");
            /*int a=10/0;*/
            return true;
        }else {
            return false;
        }

    }

    @Override
    public boolean saveUser(User user) {
        if (userDao.insert(user)>0){
            System.out.println("业务层saveUser方法执行");
            return true;
        }else {
            return false;
        }

    }
}

在aop包下面创建 UserServiceLogger

UserServiceLogger 代码

package com.zhao.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

import java.util.Arrays;

public class UserServiceLogger {
    /*前置增强*/
    public  void before(JoinPoint jp){
        System.out.println("===========前置增强========="+"调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法的入参："+ Arrays.toString(jp.getArgs()));
    }

/*后置增强*/
    public  void  after(JoinPoint jp,Object result){
        System.out.println("=======后置增强=========="+"调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法返回值"+result);
    }
    /*异常抛出增强*/
    public  void  afterThrowing (JoinPoint jp,RuntimeException e){
    System.out.println("===========异常抛出增强=============="+jp.getSignature().getName()+"方法发生异常"+e);
}


public  void  afterLogger(JoinPoint jp){
    System.out.println("=========最终增强============="+jp.getSignature().getName()+"方法结束执行!");
}



/*----------------------------------------------*/



public  Object aroundLogger  (ProceedingJoinPoint jp)throws  Throwable{
    System.out.println("=======环绕增强=========="+"调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法的入参"+Arrays.toString(jp.getArgs()));
try {
    Object result =jp.proceed();//执行目标方法并获得返回值
    System.out.println("===========环绕增强=============="+"调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法，方法返回值"+result);
return result;
}catch (Throwable e){
    System.out.println("================环绕增强================"+jp.getSignature().getName()+"方法发生异常"+e);
    throw  e;
}finally {
    System.out.println("===============环绕增强==============="+jp.getSignature().getName()+"方法体结束执行！");
}
}
}

配置文件

<?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:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	<bean id="user" class="com.zhao.entity.User" p:uname="zhaoguang" p:address="chnenggong"/>
	<bean id="UserDao" class="com.zhao.dao.UserDaoImpl"/>
	<!--依赖注入-->
	<!--<bean id="UserService" class="com.zhao.service.UserServiceImpl">
		<property name="UserDao" ref="UserDao"/>
	</bean>-->
	<!--构造注入-->
	<bean id="UserService" class="com.zhao.service.UserServiceImpl">
		<!--通过参数名称为构造方法入值：name构造函数的形参，ref引用dao层对象-->
		<constructor-arg name="userDao" ref="UserDao"/>
	</bean>
	<!--定义增强方法的对象-->
	<bean id="theLogger" class="com.zhao.aop.UserServiceLogger"/>
<!--配置切面-->
	<aop:config>
		<!--定义切点-->
		<aop:pointcut id="pointcut" expression="execution(* com.zhao.service.*.*(..))"/>
		<!--引用增强方法-->
		<aop:aspect ref="theLogger">
			<!--前置增强-->
			<aop:before method="before" pointcut-ref="pointcut"/>
			<!--后置增强-->
			<aop:after-returning method="after" pointcut-ref="pointcut" returning="result"/>
			<!--异常抛出增强-->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>
			<!--最终增强-->
			<aop:after method="afterLogger" pointcut-ref="pointcut"/>
			<!--环绕增强-->
			<aop:around method="aroundLogger" pointcut-ref="pointcut"/>
		</aop:aspect>
	</aop:config>
</beans>

测试类

package com.zhao.test;

import com.zhao.entity.User;
import com.zhao.service.IUserService;
import com.zhao.service.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    @Test
    public  void  test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserService userService= (IUserService) context.getBean("UserService");
        User user=new User();
        user.setUname("赵光远");
        user.setId(1);
        if( userService.saveUser(user)){
            System.out.println("保存成功");
        }else {
            System.out.println("保存失败");
        }

        if (userService.delUser(1)){
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }

/* User u=(User) context.getBean("user");
        System.out.println(u.getUname()+u.getAddress());*/
    }
}

运行结果

如果发生异常

我们先注销环绕增强运行结果

然后我们如果放生异常后置增强不会触发直接进入异常然后最终增强

我们把前置增强全部注销只打开环绕增强

如果环绕增强发生异常

使用配置文件给实体类的数据赋值

创建User实体类

package com.zhao.entity;

/**
 * @author xpc
 * @create 2022-12-30 15:19
 * 用户实体类
 */
public class User {
    private int id;
    private String uname;
    private  int age;
    private String address;

    public int getId() {
        return id;
    }

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

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

配置文件语句

	<bean id="user" class="com.zhao.entity.User" p:uname="zhaoguang" p:address="chnenggong"/>

测试类代码

 User u=(User) context.getBean("user");
       System.out.println(u.getUname()+u.getAddress());

运行结果