创建业务逻辑层

1.创建实体类 User

package com.time.pojo;

public class User {
    private String name;

    public String getName() {
        return name;
    }

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

2.创建UserDao

package com.time.dao;

import com.time.pojo.User;

public interface UserDao {
void seave(User user);
}

创建UserDaoimpl 并且实现我们UserDao 接口

3.在service 下创建Userservice 接口和Userviceimpl

package com.time.service;

import com.time.pojo.User;

public interface Userservice {
    void seave(User user);
}

4.创建Userviceimpl

package com.time.service;

import com.time.dao.UserDao;
import com.time.pojo.User;

public class Userserviceimpl implements Userservice {
    private UserDao userDao;    //创建UserDao

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void seave(User user) {
    userDao.seave(user);        //通过我们创建的对象 .seave 是我们 UserDao 接口里面定义的方法
    }
}

5.配置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" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--配置User实体类-->
    <bean id="user" class="com.time.pojo.User">
        <property name="name">
            <value>zhao</value>
        </property>
    </bean>
<!--配置UserDao 接口-->
    <bean id="UserDao" class="com.time.dao.UserDaoimpl"/>
<!--配置Uservice-->
    <bean id="Uservice" class="com.time.service.Userserviceimpl">
        <property name="userDao" ref="UserDao"/> <!--这里我们Userservice 里面我们定义了一个UserDao 所以我们直接 调用我们刚刚配置的UserDao 就行-->
    </bean>
<!--配置log-->
    <bean id="log" class="com.time.log.Log"/>

<aop:config>
    <!--定义切点-->
    <aop:pointcut id="pointcut" expression="execution(* com.time.service.*.*(..))"/>
    <!--引用log-->
    <aop:aspect ref="log">
        <!--切入点-->
        <aop:before method="qian" pointcut-ref="pointcut"/>
        <!--结束-->
        <aop:after-returning method="houzhi" pointcut-ref="pointcut" returning="object"/>
    </aop:aspect>
</aop:config>
</beans>

6.配置log文件类

package com.time.log;

import javafx.geometry.VPos;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Log {
    private static final Logger LOGGER = Logger.getLogger(Log.class);

    /*前置增强*/
    public void qian(JoinPoint joinPoint) {
        LOGGER.info("调用的是" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法");
        System.out.println("-----------前置增强------------");
    }

    /*后置增强*/
    public void houzhi(JoinPoint joinPoint, Object object) {
        LOGGER.info("调用的是" + joinPoint.getTarget() + "的" + joinPoint.getSignature().getName() + "方法，返回值" + object);
        System.out.println("-----------后置增强------------");


    }
}

编写测试类

package com.time.test;

import com.sun.glass.ui.Application;
import com.time.pojo.User;
import com.time.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.applet.AppletContext;

public class test01 {
    @Test
    public  void  test01(){
//读取配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Userservice uservice = (Userservice) context.getBean("Uservice");
        User user = (User) context.getBean("user");
        uservice.seave(user);
    }
}

运行结果

异常抛出增强

就是如果程序出错就会运行此代码，但是如果没有就不会运行，而是到结束

我们在dao 下面的UserDaoimpl 编写一个模拟异常的代码

package com.time.dao;

import com.time.pojo.User;

public class UserDaoimpl implements UserDao{
    @Override
    public void seave(User user) {
        System.out.println("里面的用户是"+user.getName());
        //模拟异常
         int [] ids=new int[5];
        System.out.println(ids[5]);
    }
}

在log里面进行编写

    /*异常抛出增强*/
    public void yicahng(JoinPoint joinPoint, Exception e) {
        LOGGER.info(joinPoint.getSignature().getName() + "发生了异常" + e);
        System.out.println("--------------------发生异常，处理异常---------------");//这里如果发生了异常后置增强是不会出来的，因为有了异常他是不会继续的 }
    }

在applicationContext.xml 进行编写

  <aop:after-throwing method="yicahng" throwing="e" pointcut-ref="pointcut"/>

测试类和上面的一样

package com.time.test;

import com.sun.glass.ui.Application;
import com.time.pojo.User;
import com.time.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.applet.AppletContext;

public class test01 {
    @Test
    public  void  test01(){
//读取配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Userservice uservice = (Userservice) context.getBean("Uservice");
        User user = (User) context.getBean("user");
        uservice.seave(user);
    }
}

运行结果

最终增强

不管程序是否出错他都会运行

编写log

/*最终增强*/
    public void zuizhong(JoinPoint joinPoint){
    LOGGER.info("调用的是"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法");
        System.out.println("------------最终增强-----------------");    //即便发生了异常最终增强他都会继续运行下去
    }

在applicationContext.xml 进行编写

<aop:after method="zuizhong" pointcut-ref="pointcut"/>

编写测试类一样

package com.time.test;

import com.sun.glass.ui.Application;
import com.time.pojo.User;
import com.time.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.applet.AppletContext;

public class test01 {
    @Test
    public  void  test01(){
//读取配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Userservice uservice = (Userservice) context.getBean("Uservice");
        User user = (User) context.getBean("user");
        uservice.seave(user);
    }
}

运行结果

环绕增强

可以在目标前后都可以进行设置的一种增强方式 就是把方法掉出来进行设置

编写log类

 /*环绕增强*/    //可以在目标前后都可以进行设置的一种增强方式
    public Object huanrao(ProceedingJoinPoint joinPoint) throws Throwable{
        /*打印参数信息*/
        LOGGER.info("调用的是"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法，参数："+ Arrays.toString(joinPoint.getArgs()));
        try {
            Object result = joinPoint.proceed();//执行目标方法并获取返回值
            /*打印返回值*/
            LOGGER.info("返回值"+result);
            return  result;
        }catch ( Throwable t){
            LOGGER.error(joinPoint.getSignature().getName()+"方法发生了异常"+t);
            throw t;
        }finally {
            System.out.println("------------环绕增强--------------");
        }

在applicationContext.xml 进行编写

<aop:around method="huanrao" pointcut-ref="pointcut"/>

编写测试类还是一样

package com.time.test;

import com.sun.glass.ui.Application;
import com.time.pojo.User;
import com.time.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.applet.AppletContext;

public class test01 {
    @Test
    public  void  test01(){
//读取配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Userservice uservice = (Userservice) context.getBean("Uservice");
        User user = (User) context.getBean("user");
        uservice.seave(user);
    }
}

运行结果

使用构造注入的方法

在pojo下创建Student类

package com.time.pojo;

public class Student {
private String name;
private String pwd;

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }
public void show(){
    System.out.println("他叫"+this.getName()+"密码是"+pwd);
}
    /*无参构造*/
    public Student() {
    }
    /*代餐构造*/
    public Student(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

}

创建 gouzao.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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--构造注入-->
<bean id="student" class="com.time.pojo.Student">
<constructor-arg name="name" value="zhao"/>
<constructor-arg name="pwd" value="123.com"/>
</bean>
    <!--p命名空间注入-->
    <bean id="pet" class="com.time.pojo.Pet" p:name="好郝" p:msg="50"/>

</beans>

编写测试类

package com.time.test;

import com.time.pojo.Pet;
import com.time.pojo.Student;
import com.time.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test02 {
    @Test
    public  void  test02(){
        ApplicationContext context=new ClassPathXmlApplicationContext("gouzao.xml");
        Student student = (Student) context.getBean("student");
        student.show();
    }

运行结果

p命名空间的方式

创建实体类Pet

package com.time.pojo;

public class Pet {
    private  String name;
    private  String msg;

    public String getName() {
        return name;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
    public  void  show(){
        System.out.println("姓名"+name+"年龄"+msg);
    }
}

编写测试类

    @Test
    public  void  test03(){
        ApplicationContext context=new ClassPathXmlApplicationContext("gouzao.xml");
        Pet pet = (Pet) context.getBean("pet");
        pet.show();
    }

运行结果

不同类型的注入

首先我们定义不同的字符，比如 String ,User, LIst,[], <> 等因为这些我觉得不太重要大家只需要了解就好我就不用idea演示了，有兴趣的小伙伴可以自己敲一敲

空字符串和null

空字符串就是一对<value></value> null就是单个 <null/>

基本数据类型和字符串

我们赋值的时候在<value></value>里面进行赋值的时候可以使用一些符号等可以看一看下面的照片。

集合和数组

List集合就是定义了一个List标签<List>里面使用<value>进行遍历

Set 集合就是定义一对<set>标签里面进行定义值

Map集合就是一对大标签<map>包着然后定义Map中的键值对有一个<entry>包着<key>和<value>进行赋值

在Map中如果建或者值是Bean 对象时可以把上面的<valuse> 换成 ref标签，.......大家可以看下面照片的注释

Bean 这里就不过多解释了大家看看上面和下面两张照片看看进行了解就行基本上我们用户到了解就好

使用注解简写实现Spring Ioc

1.创建业务层

创建实体类User

package com.bdqn.pojo;

public class User {
    private String name;  //tom


    public String getName() {
        return name;
    }

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



}

创建dao层并创建dao接口和实现

UserDao接口

package com.bdqn.dao;

import com.bdqn.pojo.User;

public interface UserDao {

      void save(User user);
}

UserDaoimpl 实体类

package com.bdqn.dao.impl;

import com.bdqn.dao.UserDao;
import com.bdqn.pojo.User;
import org.springframework.stereotype.Component;

@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save(User user) {
        System.out.println("成功向数据库中插入数据"+user.getName());
    }
}

创建service业务逻辑层

package com.bdqn.service;

import com.bdqn.pojo.User;

public interface UserService {

    void save(User user);


}

@Autowired 如果我们逻辑层里面有一个UserDao他会帮我们自动去找，如果有多个UserDao,我们就需要使用@Qualifier("")里面定义的时我们具体的UserDao.

编写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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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 http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--扫包-->
    <context:component-scan base-package="com.bdqn.dao,com.bdqn.service" />

</beans>

编写测试类

package com.bdqn.test;

import com.bdqn.pojo.User;
import com.bdqn.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

    @Test
    public  void  test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user = (UserService)context.getBean("userService");
        User u=new User();
        u.setName("tom");
        user.save(u);
    }
}

运行结果

使用注解实现Spring AOP

创建业务层代码

创建 UserDao接口

package com.bcsp.dao;

import com.bcsp.pojo.User;

public interface UserDao {

    void save(User user);
}

创建实体类实现UserDao接口

/* int [] ids=new int[5];
 System.out.println(ids[5]);*/

是用来模拟异常的

package com.bcsp.dao.impl;

import com.bcsp.dao.UserDao;
import com.bcsp.pojo.User;
import org.springframework.stereotype.Component;

@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save(User user) {
        int [] ids=new int[5];
        System.out.println(ids[5]);
        System.out.println("成功向数据库中保存数据："+user.getName());

    }
}

创建实体类

package com.bcsp.pojo;

public class User {
    private String name;

    public String getName() {
        return name;
    }

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

创建Uservice 接口

package com.bcsp.service;

import com.bcsp.pojo.User;

public interface UserService {
    void save(User user);

}

创建UserServiceimpl 实现接口

package com.bcsp.service.impl;

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

import javax.annotation.Resource;

@Service("userService")
public class UserServiceImpl implements UserService {

    @Resource(name="userDao")
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save(User user) {
        userDao.save(user);
    }
}

编写log类

package com.bcsp.log;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.junit.internal.Throwables;

import java.util.Arrays;

//定义切面
@Aspect
public class LogService {
    private  static  final Logger LOGGER=Logger.getLogger(LogService.class);



    @Before("execution(* com.bcsp.service.*.*(..))")
    /*前置增强*/
    public  void  before(JoinPoint joinPoint){
        LOGGER.info("调用的是"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法");
        System.out.println("--------------前置增强--------------------");
    }


    @AfterReturning(pointcut = "execution(* com.bcsp.service.*.*(..))",returning = "object")
    /*后置增强*/
    public  void  afterReturning(JoinPoint joinPoint,Object object){
        LOGGER.info("调用的是"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法,返回值为"+object);
        System.out.println("--------------后置增强--------------------");
    }

    @AfterThrowing(pointcut ="execution(* com.bcsp.service.*.*(..))",throwing = "e")
    /*异常抛出增强*/
    public  void  afterThrowing(JoinPoint joinPoint,RuntimeException e){
        LOGGER.error(joinPoint.getSignature().getName()+"发生了异常"+e);
        System.out.println("--------------异常增强--------------------");
    }
    /*最终增强*/
    @After("execution(* com.bcsp.service.*.*(..))")
    public  void after(JoinPoint joinPoint){
        LOGGER.info(joinPoint.getSignature().getName()+"结束了");
        System.out.println("--------------最终增强--------------------");
    }
    /*环绕增强*/
   @Around("execution(* com.bcsp.service.*.*(..))")
    public  Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        LOGGER.info("参数"+ Arrays.toString(joinPoint.getArgs()));
        Object proceed=null;
        try {
             proceed= joinPoint.proceed();//返回值
            System.out.println("返回值为"+proceed);
        } catch (Throwable throwable) {

                throw  throwable;
        }finally {
            LOGGER.info("结束");
        }
        System.out.println("---------------环绕增强------------------");
        return proceed;
    }


}

编写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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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 http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--扫包-->
    <context:component-scan base-package="com.bcsp.dao,com.bcsp.service" />
    <bean class="com.bcsp.log.LogService"></bean>
    <aop:aspectj-autoproxy/>
</beans>

编写测试类

package com.bcsp.test;

import com.bcsp.pojo.User;
import com.bcsp.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpTest {
    @Test
    public  void  test01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user = (UserService)context.getBean("userService");
        User u=new User();
        u.setName("tom");
        user.save(u);
    }

}

运行结果

Spring 框架深入学习增强类型扩展和依赖注入扩展

异常抛出增强

最终增强

环绕增强

p命名空间的方式

不同类型的注入

使用注解简写实现Spring Ioc

使用注解实现Spring AOP

网站公告

今日签到

热门文章

最新发布

Spring 框架深入学习增强类型扩展 和依赖注入扩展

异常抛出增强

最终增强

环绕增强

p命名空间的方式

不同类型的注入

使用注解简写实现Spring Ioc

使用注解实现Spring AOP

网站公告

今日签到

热门文章

最新发布

Spring 框架深入学习增强类型扩展和依赖注入扩展