Maven生命周期、Spring核心技术IOC与AOP、Java中创建对象的5种方式（含使用Spring）

最新推荐文章于 2022-10-07 14:06:01 发布

彼岸啊

最新推荐文章于 2022-10-07 14:06:01 发布

阅读量231

点赞数

分类专栏： JavaEE框架

本文链接：https://blog.csdn.net/qq_44495081/article/details/104336304

版权

JavaEE框架专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章目录

一、Maven
二、Spring

一、Maven

1、什么是maven

管理项目的构建，报告和文档的项目管理工具软件。将程序中要使用的jar包存在放在maven仓库中，只需要在pom.xml文档中进行配置，就可以联网获得对应的jar包，而且会将所导入的jar包的所有依赖的jar包一起导入进去。

可以简单的理解为就是一个管理项目，管理依赖的工具

2、Maven核心功能

依赖管理
模块管理
插件管理
部署管理

3、Maven生命周期

maven将工程的构建过程理解为不同的生命周期和阶段，一个工程的构建过程中，存在着不同的生命周期，生命周期间互相独立，没有一定的顺序关系。每个生命周期又划分为不同的阶段，不同的阶段之间有明确的顺序关系，同一生命周期内的阶段必须按顺序依次执行。

clear（清除）
1. pre-clean：执行清理的准备工作
2. clean：执行清理工作
3. post-clean：执行清理后的后续工作
default（核心）
1. validate：验证项目的正确性及项目所必需的信息是否可用
2. compile：编译项目中代码
3. test：用相关的单元测试框架测试编译后的代码，测试代码并不会随项目打包和布署
4. package：将编译后的代码打包成相应的格式文件，如jar包
5. integration-test：如果需要在一个综合环境中运行我们的测试，这个阶段将会运行和布署项目到该环境中
6. verify：检查项目中的包是否正确与符合要求
7. install：将包安装到本地maven仓库，其他项目也可以使用该包作为依赖
8. deploy：将包发布到远程的maven仓库，并提供给其他开发者使用
site（建立发布项目站点）
1. pre-site：准备生成
2. site：生成项目站点和文档
3. post-site：执行生成文档后的后续工作
4. site-deploy：发布项目文档

二、Spring

1、Spring的Maven仓库核心依赖

springcore4.3.18
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.18.RELEASE</version>
</dependency>

springcontext
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.18.RELEASE</version>
</dependency>

2、Java中创建对象的方法

new关键字
克隆，重写clone()方法

实体类实现Cloneable接口，重写clone()方法，调用clone()方法，克隆得到的对象与原来的对象不是一个对象
反射

得到Students类的Class对象，根据Class对象得到构造器，再根据构造器得到对象
对象反序列化

实体类实现Serializable接口，先序列化将对象写入文件中，再反序列化从文件中得到对象，记得关闭流

Students类

//Students类
package org.westos.domain;

import java.io.Serializable;

public class Students implements Cloneable, Serializable {
    private String sid;
    private String sname;
    private String gender;
    private String birthday;
    private String major;
    
    //实现Cloneable接口，重写父类的clone()方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Students{" +
                "sid='" + sid + '\'' +
                ", sname='" + sname + '\'' +
                ", gender='" + gender + '\'' +
                ", birthday='" + birthday + '\'' +
                ", major='" + major + '\'' +
                '}';
    }

    public Students() {
    }

    public Students(String sid, String sname, String gender, String birthday, String major) {
        this.sid = sid;
        this.sname = sname;
        this.gender = gender;
        this.birthday = birthday;
        this.major = major;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }
}

测试类

package org.westos.test;

import org.westos.domain.Students;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, InvocationTargetException {
        //1.使用new关键字创建对象
        Students s1 = new Students("001", "张三", "男", "1993-02-03", "古文");
        System.out.println("s1:" + s1);

        //2.使用clone()方法创建对象
        Students s2 = (Students) s1.clone();
        System.out.println("s2:" + s2);
        System.out.println(s1 == s2);//s1与s2不相等

        //3.使用反射得到对象
        Class aClass = Class.forName("org.westos.domain.Students");//使用类名得到类的Class对象
        //使用构造器的参数得到构造器
        Constructor constructor = aClass.getConstructor(String.class, String.class, String.class, String.class, String.class);
        //使用构造器得到对象
        Students s3 = (Students) constructor.newInstance(new Object[]{"002", "李四", "男", "1994-02-04", "高数"});
        System.out.println("s3:" + s3);

        //4.使用反序列化得到对象
        //得到对象输出流
        File file = new File("studentLists.text");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
        //将对象序列化写到文件studentLists.txt中
        out.writeObject(s2);
        //得到对象输入流
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        //反序列化读取对象
        Students s4 = (Students) in.readObject();
        System.out.println("s4:" + s4);
        //关闭流资源
        in.close();
        out.close();
    }
}

3、使用spring创建对象

spring也不适用new关键字创建对象，使用Ioc容器注入
先在xml配置文档里配置好对象的属性与id值，得到与配置文档的连接，根据配置文档里id属性的值，得到对象（内部也是通过反射+xml文档的解析实现的）

对象的创建是通过默认无参构造创建的，而属性的初始化时使用set方法初始化的，所以一定要保留默认的无参构造和set方法

测试类

public class IocDemo2 {
    public static void main(String[] args) {
        //使用Spring的ioc拿到对象
        //得到context对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //得到Students对象
        Students s1 = (Students) context.getBean("s1");
        System.out.println(s1);
    }
}

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

    <!--定义学生对象-->
    <bean id="s1" class="org.westos.domain.Students">
        <property name="sid" value="200"/>
        <property name="sname" value="张三丰"/>
        <property name="gender" value="男"/>
        <property name="birthday" value="1998-10-10"/>
        <property name="major" value="太极拳"/>

    </bean>
</beans>

4、spring创建对象顺序

加载applicationContext.xml文档
解析对应的id的对象
通过反射区调用默认无参构造
使用set方法初始化属性

5、spring的两大核心技术

IOC（DI），控制反转/依赖注入

如何理解依赖注入
1. 创建对象，不适用new关键字
2. 面向接口的编程，UsbInterface接口、Computer类、IocDemo3类
  
  不修改代码，使用多态的形式，用IOC在配置文档中读取对象，修改配置文档
什么是IOC容器：xml文档中的beans标签就是一个IOC容器

为什么不推荐使用new创建对象
1. 麻烦，可以直接在配置文档里面配置好，然后用的时候直接根据id属性获取对象就行了
AOP，面向切面的编程
1. 可以简单的理解为在不改变原有程序的基础上为代码增加新的功能
  2. 分为前置增强、后置增强、最终增强、异常增强、环绕增强
  3. 需要在原有的类上定义一个切口（方法），然后定义一个用于增强的AOP类，可以在类中定义增强的方法。最后在xml配置文档中进行配置

彼岸啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Maven生命周期、Spring核心技术IOC与AOP、Java中创建对象的5种方式（含使用Spring）

文章目录一、Maven1、什么是maven2、Maven核心功能3、Maven生命周期二、Spring1、Spring的Maven仓库核心依赖2、Java中创建对象的方法3、使用spring创建对象4、spring创建对象顺序5、spring的两大核心技术一、Maven1、什么是maven管理项目的构建，报告和文档的项目管理工具软件。将程序中要使用的jar包存在放在maven仓库中，只需要在...
复制链接

扫一扫

专栏目录