栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SSM总结笔记【更新中...】

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SSM总结笔记【更新中...】

SSM总结笔记

楠哥教你学Java Spring+SpringMVC+Mybatis总结笔记

Spring Spring概述
  • Spring是一个企业级开发框架,关注点在于软件设计层面
  • Spring已经成为Java领域的行业标准
  • Spring 提供了各个层面的解决方案,Spring MVC、Spring Data、Spring Cloud
  • Spring两大核心机制loC(控制反转)、AOP(面向切面)
Spring 的优点
  • 低侵入式设计
  • 独立于各种应用服务器
  • 依赖注入特性将组件关系透明化,降低了耦合度
  • 面向切面编程特性允许将通用任务进行集中式处理
  • 与第三方框架的良好整合
Spring框架两大核心机制(loC、AOP)
  • loC(控制反转) / DI(依赖注入)
  • AOP(面向切面编程)

Spring 是一个**企业级开发框架**,是软件设计层面的框架,优势在于可以将应用程序进行分层,开发者可以自主选择组件。

企业级项目特点
  • 用户数量多、数据规模大、功能模块众多
  • 性能和安全要求高
  • 业务复杂
  • 灵活多变

MVC: Struts2、Spring MVC
ORMapping: Hibernate、MyBatis、Spring Data

SpringIoC

控制反转

在传统的程序开发中,需要调用对象时,通常由调用者来创建被调用者的实例,即对象是由调用者主动new出来的。
但在Spring框架中创建对象的工作不再由调用者来完成,而是交给loC容器来创建,再推送给调用者,整个流程完成反转,所以是控制反转。

如何使用IoC
  • 创建Maven工程,pom.xml添加依赖


    4.0.0

    com.liner
    ssmdemo
    1.0-SNAPSHOT


    
        
            org.springframework
            spring-context
            5.3.19
        

    

    
        8
        8
    



  • 创建实体类Student
@Data
public class Student {
    private String name;
    private int age;
}
  • 传统开发方式,手动new一个Student
Student student = new Student();
student.setName("小张");
student.setAge (12);
system.out.println(student);
  • 使用控制反转,通过IoC创建Student,在配置文件中添加需要管理的对象,XML格式的配置文件,文件名可以自定义。



    
        
        
    

  • 从IoC中获取对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
配置文件
  • 通过配置bean标签来完成对象的管理。
    • id:对象名。
    • class:对象的模版类(所有交给loC容器来管理的类必须有无参构造函数,因为Spring 底层是通过反射机制来创建对象,调用的是无参构造)
  • 对象的成员变量通过property标签完成赋值。
    • name:成员变量名。
    • value:成员变量值(基本数据类型,String 可以直接赋值,如果是其他引用类型,不能通过value赋值)
    • ref:将loC中的另外一个bean赋给当前的成员变量(DI)
IoC底层原理
  • 读取配置文件,解析XML。
  • 通过反射机制实例化配置文件中所配置所有的bean。
public class ClassPathXmlApplicationContext implements ApplicationContext {

    private Map ioc = new HashMap<>();

    public ClassPathXmlApplicationContext(String path) {
        try {
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read("./src/main/resources/" + path);
            Element root = document.getRootElement();
            Iterator iterator = root.elementIterator();
            while (iterator.hasNext()) {
                Element element = iterator.next();
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                //通过反射机制创建对象
                Class clazz = Class.forName(className);
                //获取无参构造 创建目标对象
                Constructor constructor = clazz.getConstructor();
                Object o = constructor.newInstance();

                //给目标对象赋值
                Iterator beanIter = element.elementIterator();
                while (beanIter.hasNext()) {
                    Element property = beanIter.next();
                    String name = property.attributeValue("name");
                    String valueStr = property.attributeValue("value");

                    String ref = property.attributeValue("ref");
                    if (ref == null) {  //普通赋值
                        //将首字母变大写
                        String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);

                        Field field = clazz.getDeclaredField(name);
                        Method method = clazz.getDeclaredMethod(methodName, field.getType());
                        System.out.println(method);
                        //根据成员变量的类型将value进行转换
                        Object value = null;
                        System.out.println(field.getType().getName());

                        if (field.getType().getName() == "java.lang.String") {
                            value = valueStr;
                        }
                        if (field.getType().getName() == "int") {
                            value = Integer.parseInt(valueStr);
                        }
                        method.invoke(o, value);
                    }
                    ioc.put(id, o);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object getBean(String id) {
        return ioc.get(id);
    }
}

  • 从IoC中获取对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);

或

  • 通过运行时类获取bean
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Student student = (Student) context.getBean(Student.class);
System.out.println(student);
//这种方式存在一个问题,配置文件中一个数据类型的对象只能有一个实例,否则会抛出异常,因为没有唯一的bean。

通过有参构造创建bean

  • 在实体类中创建对应的有参构造函数。
  • 配置文件

    
    
    
    

给bean注入集合


    
    
    
    
        
            
        
    

    
    

scope 作用域

Spring 管理的bean是根据scope 来生成的,表示 bean的作用域,共4种。

  • singleton:单例,表示通过Spring容器获取的bean是唯一的。 默认值
  • prototype:原型,表示通过Spring容器获取的bean是不同的。
  • request:请求,表示在一次HTTP请求内有效。
  • session:回话,表示在一个用户会话内有效。

request和session 只适用于Web项目,大多数情况下,使用单例和原型较多。

  • prototype模式当业务代码获取loC容器中的bean时,Spring才去调用无参构造创建对应的bean
  • singleton模式无论业务代码是否获取loC容器中的bean,Spring 在加载spring.xml时就会创建bean
Spring的继承

与Java的继承不同,Java是==类层面的继承==,子类可以继承父类的内部结构信息;

Spring 是==对象层面的继承==,子对象可以继承父对象的属性值。


   
    
    



    

Spring 的继承关注点在于具体的对象,而不在于类,

即不同的两个类的实例化对象可以完成继承,前提是==子对象必须包含父对象的所有属性==,同时可以在此基础上添加其他的属性。

Spring的依赖

与继承类似,依赖也是描述bean和bean之间的一种关系,配置依赖之后,被依赖的bean一定先创建,再创建依赖的bean,A依赖于B,先创建B,再创建A。



    
   	

Spring 的 p命名空间

p命名空间是对IoC/DI的简化操作,使用p命名空间,可以更加方便的完成bean的配置以及bean之间的依赖注入





    
    



Spring 的工厂方法

loC通过工厂模式创建bean的方式有两种:

  • 静态工厂方法
//创建一个Car的实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car {
    private Long id;
    private String name;
}
//创建一个静态工厂
public class StaticCarFactory {
    private static Map carMap;
    static {
        carMap = new HashMap();
        carMap.put(1L,new Car(1L,"长城"));
        carMap.put(2L,new Car(2L,"长安"));
    }

    public static Car getCar(Long id) {
        return carMap.get(id);
    }
}


    

  • 实例工厂方法
//创建一个Car的实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Car {
    private Long id;
    private String name;
}
//创建一个实例工厂
public class InstanceCarFactory {
    private Map carMap;

    public InstanceCarFactory() {
        carMap = new HashMap();
        carMap.put(1L,new Car(1L,"长城"));
        carMap.put(2L,new Car(2L,"长安"));
    }

    public Car getCar(Long id) {
        return carMap.get(id);
    }
}




    

loC自动装载(Autowire)

loC负责创建对象,DI负责完成对象的依赖注入,通过配置property标签的 ref属性来完成,同时Spring 提供了另外一种更加简便的依赖注入方式∶自动装载,不需要手动配置property,loC容器会自动选择bean完成注入。

自动装载有两种方式:

  • byName:通过属性名自动装载

    
    


	
	

  • byType:通过属性的数据类型自动装载

    
    


	
	

注意:使用byType需要注意,如果==同时存在两个及以上的符合条件==的bean时,自动装载会抛出异常。

SpringAOP

AOP: Aspect Oriented Programming 面向切面编程

AOP的优点
  • 降低模块之间的耦合度
  • 使系统容易扩展
  • 更好的代码复用
  • 非业务代码更加集中,不分散,便于统一管理业务代码更简洁纯粹,没有其他代码的影响
  • 将复杂的需求分解出不同方面,将散布在系统中的公共功能集中解决

AOP是对面向对象编程的一个补充,在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程。将不同方法的同一个位置抽象成一个切面对象,对该切面对象进行编程就是AOP。

如何使用AOP
  • 创建Maven工程,pom.xml添加依赖

    org.springframework
    spring-aop
    5.3.19



    org.springframework
    spring-aspects
    5.3.19



    org.springframework
    spring-context
    5.3.19

  • 创建一个计算器接口,实现加减乘除四个方法
public interface Cal {
    public int add(int num1,int num2);//加法
    public int sub(int num1,int num2);//减法
    public int mul(int num1,int num2);//乘法
    public int div(int num1,int num2);//除法
}
  • 创建接口实现类
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法的参数: num1:" + num1 + " ,num2:" + num2);
        int result = num1 + num2;
        System.out.println("add方法的结果是:" + result);
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        System.out.println("sub方法的参数: num1:" + num1 + " ,num2:" + num2);
        int result = num1 - num2;
        System.out.println("sub方法的结果是:" + result);
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        System.out.println("mul方法的参数: num1:" + num1 + " ,num2:" + num2);
        int result = num1 * num2;
        System.out.println("mul方法的结果是:" + result);
        return result;
    }

    @Override
    public int div(int num1, int num2) {
        System.out.println("div方法的参数: num1:" + num1 + " ,num2:" + num2);
        int result = num1 / num2;
        System.out.println("div方法的结果是:" + result);
        return result;
    }
}

上述代码中,日志信息和业务逻辑的耦合性很高,不利于系统的维护,使用AOP可以进行优化。

如何来实现AOP
  • 使用**动态代理**的方式来实现。

给业务代码找一个代理,打印日志信息的工作交个代理来做,这样业务代码只需 关注自身的业务即可。

public class MyInvocationHandler implements InvocationHandler {

    //接收委托对象
    private Object object = null;

    //返回代理对象
    public Object bind(Object object){
        this.object = object;
        //返回一个代理实例 即 代理对象
        
        //通过该方法可获得 动态代理对象
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);
    }


    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println( method.getName() + "方法的参数: " + Arrays.toString(args));
        //当前目标方法 通过反射机制 调用委托对象的方法
        Object result = method.invoke(this.object, args);//让委托对象调用自己的方法
        System.out.println( method.getName() + "方法的结果是: " + result);

        return result;
    }
}
//创建接口实现类
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    @Override
    public int sub(int num1, int num2) {
        return num1 - num2;
    }

    @Override
    public int mul(int num1, int num2) {
       return num1 * num2;
    }

    @Override
    public int div(int num1, int num2) {
        return num1 / num2;
    }
}
public static void main(String[] args) {
    //委托对象 cal
    Cal cal = new CalImpl();
    MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
    //bind() 将委托对象传进去  返回 动态代理对象  proxy
    Cal proxy = (Cal) myInvocationHandler.bind(cal);
    proxy.add(1,2);  //实际进入的是  MyInvocationHandler 的 invoke()里
    proxy.sub(2,2);
    proxy.mul(3,2);
    proxy.div(2,2);

}

以上是通过**动态代理实现AOP**的过程,比较复杂,不好理解,Spring框架对AOP进行了封装

  • 使用Spring框架可以用面向对象的思想来实现AOP。

Spring框架中**不需要创建InvocationHandler**,只需要==创建一个切面对象==,将所有的非业务代码在切面对象中完成即可,Spring框架底层会自动根据切面类以及目标类生成一个代理对象。

LoggerAspect

@Aspect //给它个切面的功能
@Component  //让IoC管理它
public class LoggerAspect {}

    
    //通过 execution 表达式去关联
       @Before("execution(public int com.liner.spring.springAOP.utils.impl.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        //获取参数
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println( name + "方法的参数: " + args);
    }

    @After("execution(public int com.liner.spring.springAOP.utils.impl.CalImpl.*(..))")
    public void After(JoinPoint joinPoint){
        //获取方法名
        String name = joinPoint.getSignature().getName();

        System.out.println(name + "方法执行完毕....." );
    }


    @AfterReturning(value = "execution(public int com.liner.spring.springAOP.utils.impl.CalImpl.*(..))",returning = "result")
    public void AfterReturning(JoinPoint joinPoint, Object result){
        //获取方法名
        String name = joinPoint.getSignature().getName();
        //获取结果
        System.out.println(name + "方法执行结果为:" + result);
    }

     @AfterThrowing(value = "execution(public int com.liner.spring.springAOP.utils.impl.CalImpl.*(..))", throwing = "exception")
        public void AfterThrowing(JoinPoint joinPoint, Exception exception){
            //获取方法名
            String name = joinPoint.getSignature().getName();
            //获取结果
            System.out.println(name + "方法执行抛出的异常为:" + exception);
    }

}

LoggerAspect类定义处添加的两个注解:

  • Aspect:表示该类是切面类。

  • component:将该类的对象注入到loC容器。

具体方法处添加的注解:

@Before:表示方法执行的具体位置和时机。

Callmpl也需要添加@Component,交给loC容器来管理。

@Component
public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    @Override
    public int sub(int num1, int num2) {
        return num1 - num2;
    }

    @Override
    public int mul(int num1, int num2) {
       return num1 * num2;
    }

    @Override
    public int div(int num1, int num2) {
        return num1 / num2;
    }
}

在Spring.xml中配置AOP





    
    
    
    



context:component-scan 将com.liner.spring.springAOP包中的所有类进行扫描,如果该类同时添加了@Component,则将该类扫描到loC容器中,即loC管理它的对象。
aop:aspectj-autoproxy 让Spring框架结合切面类和目标类自动生成动态代理对象。

  • 切面:横切关注点被模块化的抽象对象。
  • 通知:切面对象完成的工作。
  • 目标:被通知的对象,即被横切的对象。·
  • 代理:切面、通知、目标混合之后的对象。
  • 连接点:通知要插入业务代码的具体位置。
  • 切点:AOP通过切点定位到连接点。
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950674.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号