Spring中Maven的创建以及实例化的过程

最新推荐文章于 2023-05-05 23:02:01 发布

weixin_45801172

最新推荐文章于 2023-05-05 23:02:01 发布

阅读量336

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/weixin_45801172/article/details/103604180

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring笔记

第一节:Spring框架概念、模块划分与环境搭建

Spring框架概念

Spring 是众多开源 java 项目中的一员，基于分层的 javaEE 应用一站式轻量级开源框架，主要核心是 Ioc(控制反转/依赖注入) 与 Aop(面向切面)两大技术，实现项目在开发过程中的轻松解耦，提高项目的开发效率。在项目中引入 Spring 立即可以带来下面的好处降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。容器提供单例模式支持，开发人员不再需要自己编写实现代码。容器提供了 AOP 技术，利
用它很容易实现如权限拦截、运行期监控等功能。

Spring结构图

在这里插入图片描述

Spring的划分

层级	作用	对应的框架
Dao层	JDBC处理(BeseDao)	MyBatis
Service	实现业务逻辑	Spring框架不是针对Service的业务逻辑,没有合适的框架
Web层(Controller层)	接收请求,返回响应	SpringMVC

Spring基于分布式的应用程序

Spring是基于轻量级的框架,存在以下技术

配置管理
Bean对象的实例化-IOC
集成其他第三方技术,例如MyBatis、Hibernate（持久化框架）、SpringMVC
自带的服务，例如：Mail邮件处理、定义任务处理-定时调度（定时短信、定时任务）、消息异步处理

Spring模块划分-重点

模块	作用
Spring IOC模块	Bean对象实例化 Bean的创建
Spring AOC模块	动态代理面向切面编程
Spring JDBC+事物
Spring Web模块

Spring的环境搭建

1.新建Maven项目

选择"File"->选择"New"->选择Maven

在这里插入图片描述

2.设置项目的坐标

在这里插入图片描述

3.设置项目的Maven环境

在这里插入图片描述

4.设置项目的名称和存放的工作空间

在这里插入图片描述

5.修改项目中pom.xml的配置

在这里插入图片描述

5.1修改JDK的版本

 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--其他版本改成1.8-->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

5.2修改单元测试的版本

 <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
       <!--其他版本改成4.12-->
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

5.3删除build标签中的pluginManagement标签

 <!--删除build标签中的pluginManagement标签-->
  <build>
  </build>

5.4添加Spring的依赖坐标

Maven仓库:https://mvnrepository.com/

<!--添加Spring的依赖坐标-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.9.RELEASE</version>
</dependency>

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

6.添加Spring的配置文件Spring.xml

6.1在src/main下新建一个resources文件,将其标记为Resources Root

在这里插入图片描述

6.2在其目录下,新建一个spring.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->

</beans>

7.创建Bean对象

在这里插入图片描述

8.通过Spring.xml配置Bean对象

修改Spring.xml的id和class的值

<!--id为唯一标识,其他资源会到这个配置文件找,class表示引用资源的地址,一般为包名+类名-->
<bean id="userService" class="com.shsxt.service.UserService"></bean>

其他文件件使用时候,需要先引入这个文件,会根据id值找到对应的class的值,会找到包下的类名

9.加载配置文件,获取实例化对象

 public static void main(String[] args) {
        // 加载配置文件,获取Spring上下文环境
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        // 通过getBean方法得到Spring容器中实例化好的Bean对象
        UserService userService = (UserService) ac.getBean("userService");
        // 调用方法
        userService.test();
    }

第二节:Spring IOC容器Bean对象实例化模拟

1.引入dom4j的依赖和jaxen的依赖,将其加载到pom.xml配置文件中

	<!--dom4j的依赖-->
    <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
	<!--jaxen的依赖-->
	<dependency>
        <groupId>jaxen</groupId>
        <artifactId>jaxen</artifactId>
        <version>1.1.1</version>
    </dependency>

2.准备一个Bean

public class WzmBean {
    private String id;
    private String clazz;

    public WzmBean() {
    }
    public WzmBean(String id, String clazz) {
        this.id = id;
        this.clazz = clazz;
    }

    public String getId() {
        return id;
    }

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

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

3.准备一个BeanFactory工厂接口

public interface Wzmfactory {
    Object getBean(String bean);

}

4.实现类(实现BeanFactory工厂)

public class WzmClassPathXmlApplicationContext implements Wzmfactory {
    private List<WzmBean> beans;//存放bean
    private Map<String,Object> target=new HashMap<String,Object>();//用于存放id和实例化的对象
   /* 模拟SPring实现
   * 1.通过构造器得到相关配置文件
   * 2.通过dom4j解析xml文件,得到List,存放id和class
   * 3.通过反射实例化得到的对象
   * 4.得到指定实例化对象
   *
   * */
    //1.通过构造器得到相关配置文件
    public WzmClassPathXmlApplicationContext(String fileName) throws DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        //1.1通过dom4j解析xml文件
        this.parseXml(fileName);
        //1.2通过反射实例化对象
        this.instanceBean();
    }
    //1.1通过dom4j解析xml文件,得到的是一个存放好bean对象的容器
    private void parseXml(String fileName) throws DocumentException {
        //1.1.1获取解析器
        SAXReader reader=new SAXReader();
        //1.1.2得到配置文件的url
        URL url=this.getClass().getClassLoader().getResource(fileName);
        //1.1.3通过解析器解析xml文件
        Document document=reader.read(url);
        //1.1.4通过指定语法,获取元素 beans下的所有bean
        XPath xPath=document.createXPath("beans/bean");
        //1.1.5将获取的bean设置到集合中
        List<Element> list=xPath.selectNodes(document);
        //1.1.6判断集合(bean)是否为空,不为空,将获取id对应的值和获取到的class对应的值设置到对象中
        if (list!=null&&list.size()>0){
            //1.1.6.1设置一个对象集合Bean,用于存放对象
            beans=new ArrayList();
            //1.1.6.2遍历集合(bean元素集合)
            for (Element el:list){
                //id对应的值
                String idBean=el.attributeValue("id");
                //class对应的值
                String clazzBean=el.attributeValue("class");
                //将id对应的值 和 class对应的值,设置到对象中
                WzmBean wzmBean=new WzmBean(idBean,clazzBean);
                //将设置到对象,设置到集合中
                beans.add(wzmBean);
            }
        }
    }
    //1.2通过反射实例化对象
    private void instanceBean() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //1.2判断beans是否为空,不为空,将其实例化,并存储到Map中
        if (beans!=null&&beans.size()>0){
            //遍历beans中的每个对象
            for (WzmBean bean:beans) {
                //将每一个对象,都设置到Map中,第一个参数 id值,第二个参数实例化好的对象
                target.put(bean.getId(),Class.forName(bean.getClazz()).newInstance());
            }


        }
    }

    //返回一个创建好的实例
    @Override
    public Object getBean(String bean) {
        return target.get(bean);
    }
}

5. Test类

package com.shsxt.test;

import com.shsxt.service.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

class test01 {
    public static void main(String[] args){
        //方式一:用application方式接收spring.xml文件的内容
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
        //通过getBean方法得到Spring容器中实例化好的Bean对象
        UserService userService= (UserService) ac.getBean("userService");
        //调用方法
        userService.test();

        //方式二:用Beanfactory接收获取工厂
        BeanFactory factory=new ClassPathXmlApplicationContext("spring.xml");
        //通过getBean方法得到spring容器中实例化的Bean对象
        UserService userService01= (UserService) factory.getBean("userService");
        //调用方法
        userService01.test();
    }
}

6.总结

Spring IOC核心技术

模式
工厂设计模式(简单工厂工厂方法抽象方法)–可参考大话设计模式.pdf
XML解析(Dom4j)
反射(实例化对象,反射获取方法,反射获取属性,反射获取构造器,反射方法调用)
策略模式(加载资源)
单例(IOC创建的实例化对象都是单例)

第三节:Spring IOC配置文件加载&Bean对象实例化

Spring IOC配置文件加载

方式一:根据相对路径加载资源(只需要修改测试文件即可)

ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml");

方式二:根据绝对路劲加载资源(只需要修改测试文件即可)

ApplicationContext ac02=new FileSystemXmlApplicationContext("E:\\sxtallfile\\formal\\Third\\studentCode\\maven_idea\\mavensecond\\spring02\\src\\main\\resources\\spring.xml");

Test文件

class test02 {
    public static void main(String[] args){
        //前:方式一采用相对路径加载配置文件
        //用application方式接收spring.xml文件的内容
        ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml");
        //通过getBean方法得到Spring容器中实例化好的Bean对象
        UserService userService01= (UserService) ac01.getBean("userService");
        //调用方法
        userService01.test();

        //前:方式二:采用绝对路径加载配置文件
        //用application方式接收spring.xml文件的内容,这里采用绝对路径
        ApplicationContext ac02=new FileSystemXmlApplicationContext("E:\\sxtallfile\\formal\\Third\\studentCode\\maven_idea\\mavensecond\\spring02\\src\\main\\resources\\spring.xml");
        //通过getBean方法得到Spring容器中实例化好的Bean对象
        UserService userService02= (UserService) ac02.getBean("userService");
        //调用方法
        userService02.test();
    }
}

方式三:多文件加载

1.可变参数引入

ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml","dao.xml");

2.通过总的配置文件import其他配置文件(xml文件都是放在src/main/resources下)

dao.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="userDao" class="com.shsxt.dao.UserDao">
    </bean>

</beans>

spring.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.shsxt.service.UserService">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

</beans>

manage.xml文件,引入上面两个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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <import resource="dom.xml"/>
    <import resource="spring.xml"/>

</beans>

测试文件

public class test03 {
    public static void main(String[] args) {
        //1.同时加载多个资源文件
        ApplicationContext ac=new ClassPathXmlApplicationContext("dom.xml","spring.xml");
        //2.1通过getBean()方法得到Spring容器中实例好的Bean对象 userService
        UserService userService= (UserService) ac.getBean("userService");
        //2.2通过getBean()方法得到Spring容器中是实例好Bean对象 userDao
        UserDao userDao= (UserDao) ac.getBean("userDao");
        //2.3测试实例对象的方法
        userService.test();
        userDao.test();
    }
}

Spring IOC Bean对象实例化

方式一:通过bean的缺省构造函数实例化Bean对象

注:通过默认构造器创建空构造方法必须存在,否则创建失败

Test文件(test)

  		//用application方式接收spring.xml文件的内容
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
        //通过getBean方法得到Spring容器中实例化好的Bean对象
        UserService userService= (UserService) ac.getBean("userService");
        //调用方法
        userService.test();

配置文件(spring1.xml)

    <bean id="userService" class="com.shsxt.service.UserService">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

方式二:通过静态工厂实例化Bean

Test文件(test)

public class test04 {
    public static void main(String[] args) {
        //1.加载资源文件
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring03.xml");
        //2.通过静态工厂获取Bean对象
        UserController userController= (UserController) ac.getBean("userController");
        //3.测试Bean对象的方法
        userController.test();
        //4.检查是否单例
        System.out.println("是否单例:"+ac.isSingleton("userController"));
    }
}

配置文件(spring2.xml)

 <bean id="userController" class="com.shsxt.factory.StaticFactory" factory-method="createUsersService"></bean>

方式三:实例化工厂创建Bean

Test文件(test)

	public class test04 {
    public static void main(String[] args) {
        //1.加载资源文件
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring03.xml");
        //2.通过静态工厂获取Bean对象
        UserController userController= (UserController) ac.getBean("userController");
        //3.测试Bean对象的方法
        userController.test();
        //4.检查是否单例
        System.out.println("是否单例:"+ac.isSingleton("userController"));
    }
}

配置文件(spring3.xml)

 	 <!--实例工厂-->
   <bean id="intanceFactory" class="com.shsxt.factory.IntanceFactory"></bean>
    <bean id="userController" factory-bean="intanceFactory" factory-method="createUser"></bean>

XmlApplicationContext(“spring03.xml”);
//2.通过静态工厂获取Bean对象
UserController userController= (UserController) ac.getBean(“userController”);
//3.测试Bean对象的方法
userController.test();
//4.检查是否单例
System.out.println(“是否单例:”+ac.isSingleton(“userController”));
}
}


##### 配置文件(spring3.xml)

```xml
 	 <!--实例工厂-->
   <bean id="intanceFactory" class="com.shsxt.factory.IntanceFactory"></bean>
    <bean id="userController" factory-bean="intanceFactory" factory-method="createUser"></bean>

weixin_45801172

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring中Maven的创建以及实例化的过程

Spring笔记第一节:Spring框架概念、模块划分与环境搭建Spring框架概念 Spring 是众多开源 java 项目中的一员，基于分层的 javaEE 应用一站式轻量级开源框架，主要核心是 Ioc(控制反转/依赖注入) 与 Aop(面向切面)两大技术，实现项目在开发过程中的轻松解耦，提高项目的开发效率。在项目中引入 Spring 立即可以带来下面的好处降低组件之间的耦合度,实...
复制链接

扫一扫

专栏目录