Spring学习记录01

最新推荐文章于 2022-04-20 23:23:20 发布

Nobita98

最新推荐文章于 2022-04-20 23:23:20 发布

阅读量273

点赞数

文章标签：监督学习

本文链接：https://blog.csdn.net/qq_43322095/article/details/110792353

版权

JavaEE概述第一阶段：Java2.0 版本提出Java划分为3大平台;JavaSE：标准版（桌面应用：eclipse ，Navicat，IDEA）JavaME：微型版（移动端应用）JavaEE：企业版（开发大型企业应用）大型企业应用需求1、高并发（能够支持大量的用户同时在线几万-几百万）；2、大数据量（单表的数据可能都达到几千万）；3、支持分布式事务；4、支持集群，支持负载均衡；注意：单台的tomcat 在单位时间1s内，能支持0-500个并发请求；需要的技术轻量级框架

摘要由CSDN通过智能技术生成

JavaEE概述

第一阶段：Java2.0 版本提出Java划分为3大平台;

JavaSE：标准版（桌面应用：eclipse ，Navicat，IDEA）

JavaME：微型版（移动端应用）

JavaEE：企业版（开发大型企业应用）

大型企业应用需求

1、高并发（能够支持大量的用户同时在线几万-几百万）；

2、大数据量（单表的数据可能都达到几千万）；

3、支持分布式事务；

4、支持集群，支持负载均衡；

注意：单台的tomcat 在单位时间1s内，能支持0-500个并发请求；

需要的技术

轻量级框架 + POJOS；

POJOS

就是普通的Java类，就是一个普通的JavaBean；

所谓的普通Java类就是指，一个Java类身上没有强制性的要求必须要继承什么类或必须实现什么接口的方法;

POJOS的作用：传输数据以及处理业务；

轻量级的框架

轻量级框架是相对于重量级框架来定义的，重量级框架（EJB）我们不需要学习；

轻量级框架特点：

1、它把业务和其他框架任务进行分离，业务就交给POJOS来处理；组件的管理，AOP切面的实现，数据库的访问，这些任务就让轻量级框架来处理；

2、它对代码的侵入式不高（甚至有的框架在代码中都看不到代码）;

3、它提倡“面向对象编程”；

4、它不依赖与某些外部的特殊的服务器，直接使用main()或者Junit这种测试框架，即可完成对功能的测试；

轻量级框架的分类：

表现层：struts1/2 ，springmvc

业务层：(面向对象编程，面向过程编程);

持久层：hibernate，mybatis，spring-data-jpa（orm）

注意：spring框架来做全体把控；

重量级框架（了解）

重量级框架的特点：

它既可以处理业务，又可以传输数据，还可以提供集群支持，也可以提供分布式事务；

但是：

1、它提倡“面向过程编程”；

2、它过于依赖某些API ，类如 Servlet 继承HTTPServlet；

3、过于依赖服务器（对于开发、测试、部署都非常麻烦）；

4、它对于代码的侵入式很高；

所以才有了轻量级框架；

Spring

spring：整合框架，管理各层的组件(java类)，维护组件间的关系，AOP（事务，日志）;

spring衍生的框架：springioc ，springMVC，springboot，springdata，springcloud；

准备工作1

–配置maven环境

作用：

自动下载jar包，并管理jar包;

管理jar包之间的依赖关系；

可以帮我们测试，上线，部署，打包(java是jar，web是war包);

maven：它是项目管理工具

maven 是apache开源平台上的一个免费开源项目;

1、下载：http://maven.apache.org/download.cgi

2、安装：首先，在D:\Program Files 目录下，解压apache-maven-3.6.3-bin.zip；

记录bin目录以上的位置：D:\software\apache-maven-3.6.3-bin\apache-maven-3.6.3

3、配置：

在系统变量中，添加M2_HOME

M2_HOME=D:\Program Files\apache-maven-3.6.0-bin\apache-maven-3.6.0

找到path变量,在path中添加 (win10 系统中，不用添加;)

%M2_HOME%\bin

保存环境变量

4、测试是否配置OK：

打开DOC命令创建，输入：mvn -v，若出现版本信息，则表示安装正确。

5、maven原理

6、配置本地仓库

打开安装目录 conf 下的settings.xml文件

修改：

然后再D盘中，创建一个目录repo。

7、替换国外的maven源为国内的

把国外的源，替换成国内阿里加速源！

在settings.xml 中 mirrors 节点中，添加如下内容：

<mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url> 
    </mirror>

准备工作2

–替换idea。

跟着安装文档走就行。

JavaBean编程规范

JavaBean 是领域对象来自于对客户需求的分析，这个对象既具有行为也具有属性。

要求：

1、所有的JavaBean 都必须实现序列化接口；

2、Java 中的所有属性都必须是私有的，并按需提供getter和setter方法；

3、如果需要定义有参构造器，需要先提供无参构造器；

4、toString可提供也可以不提供；

Java程序设计原则

开发程序，都需要满足“高内聚，低耦合”；

如何才能做到？

答：此时就需要从设计层面上，满足：7大设计原则，23个设计模式；

七大原则

1、单一原则：一个类只做一件事；

2、开闭原则：新需求来了，需要对新功能的扩展是开放的，而对旧功能的修改是关闭的。

3、接口隔离原则：接口最小化原则，设计接口时，接口中的方法要尽量少；

4、依赖倒置原则：层次之间相互依赖，应该是上层依赖下层的抽象，而不依赖下层的具体实现，下层应该对上层无知（不知道上层的任何代码）；

5、里氏替换原则：父类出现的任何地方，子类都可以替代；（意思是子类不要去重写父类已经实现过的方法）；

6、迪米特法则：最少知道原则，定义类的时候，只和方法的参数、方法的返回、成员变量等相关类进行交互。

7、组合，聚合原则：遇到重复代码的问题。

以前解决的方法：以前是通过继承，但是继承会破坏封装，以及增大了继承的冗余度；

现在的方法：解决了以前方法的问题;

Maven项目的目录结构

Maven项目的约定

src/main/java 核心代码；

src/main/resources 配置文件所存放的位置;

src/test/java 测试代码;

src/test/resources 测试的配置文件所存放的位置；

pom.xml：project object model 项目对象模型，这篇配置文件，主要用来描述，项目是如何组成的。

pom.xml

每个项目都是由3部分构成：

<!--项目的坐标-->
  <groupId>org.example</groupId>         //叫做组织机构
  <artifactId>springIoc</artifactId>     //是你的项目名称
  <version>1.0-SNAPSHOT</version>        //项目当前的版本

项目全局配置信息：

<!--全局配置信息-->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

定义依赖关系：

 <!--指定依赖关系-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- <scope>test</scope>  表示该jar包 仅在测试阶段有效-->
    <!-- <scope>compile</scope>  表示该jar包 仅在编译阶段有效-->
    <!-- <scope>runtime</scope>  表示该jar包 在运行期间有效-->
  </dependencies>

定义插件关系（几乎不用修改）：

<build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

Spring框架

定义

spring框架是03年由Rod Johnson创建，该框架的主要作用：让我们的应用程序满足“高内聚，低耦合”，并始终遵循面向接口编程的思想，来做到松散耦合，主要解决的业务逻辑层和其他各层的松耦合问题。

Spring核心框架

Spring框架的核心：IOC（容器），AOP（面向切面编程）;

Spring 框架的特点

1、方便程序解耦，简化开发（高内聚低耦合）；

–它的底层采用的是：工厂+反射+配置文件来实现。

（1）它可以帮助程序员去创建组件的实例；

（2）它可以程序员去管理组件之间的依赖关系；

2、AOP编程的支持

–Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行等功能。

3、声明式事务的支持

–只需要通过配置就可以完成对事务的管理，而无需手动编程。

4、方便程序的测试

–Spring对Junit4（单元测试）支持，可以通过注解方便的测试Spring程序。

5、方便集成各种优秀的框架

–Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。

6、降低JavaEE API 的使用难度。

–Spring对JavaEE 开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API 应用难度大大降低。

Spring体系结构—7大功能模块（重点）

–Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean 的方式，如图所示：

1、核心容器（Spring Core）

–核心容器提供Spring框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory使用强制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

2、Spring 上下文（Spring Context）

–Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、检验和调度功能。

3、Spring AOP

–通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了Spring框架中。所以，可以会让你容易地使Spring 框架管理的任何对象支持 AOP。Spring AOP模块基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖 EJB组件，就可以将声明性事务管理集成到应用程序中。、

4、Spring Dao

–JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误信息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向JDBC 的异常遵从通用的DAO异常层次结构。

5、Spring ORM

–Spring 框架插入了若干个ORM框架，从而提供了ORM的对象关系工具，其中包括JDO、Hibernate和 iBatis SQL Map。所有这些都遵从Spring的通用事务和DAO 异常层次结构。

6、Spring Web 模块

–Web 上下文模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。所以，Spring 框架支持Jakarta Struts 的集成。Web还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

7、Spring MVC 框架

–MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成高度可配置的，MVC容纳了大量的视图技术，其中包括了JSP、Velocity、Tiles、iText 和 POI。

Spring容器的核心类

1、 BeanFactory接口；

2、 ApplicationContext接口；

——ApplicationContext接口继承了 BeanFactory 接口，它们两个的实现类都可以成为Spring容器。

——Spring容器实际上就是一个超大型的工厂，它的底层：工厂+反射。

——BeanFactory 提供了容器的所有功能，但还是需要ApplicationContext，原因是：

BeanFactory 在产生实例的时候，是调用 getBean()方式时，才产生实例；

而ApplicationContext 在创建容器实例的时候，就开始初始化创建所有组件的实例。

——我们一般用的更多是ApplicationContext来作为容器（因为效率高）。

——ApplicationContext 除了实现了BeanFactory的所有功能之外，还扩展了很多其他动能：支持i18n(国际化) 支持任务调度，支持邮件服务，支持WebSocket等。

ApplicationContext接口

实现类：（1）ClassPathXmlApplicationContext、（2）FileSystemXmlApplicationContext、（3）AnnotationConfigApplicationContext（注解）。

区别：

——ClassPathXmlApplicationContext 使用相对路径加载applicationContext.xml配置文件;

——FileSystemXmlApplicationContext使用绝对路径加载applicationContext.xml配置文件；

——AnnotationConfigApplicationContext 提供注解支持。

——注意：但是这三者在管理组件、和维护组件的方式上，都是一样的，没有什么区别。

在代码中如何启动容器

//开启一个Spring容器
 ApplicationContext context = new AnnotationConfigApplicationContext("classpath:applicationContext.xml");

Spring框架开发步骤

文字流程

1、创建一个Maven项目；

2、在pom.xml 导入spring的依赖包；

<!--导入spring框架的依赖包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>

3、定义需要的JavaBean;

4、针对业务，定义三层架构的各层接口；

5、针对接口进行编写实现类，并完成面向接口编程。

6、板鞋applicationContext.xml 配置文件，在配置文件中，使用标记来申明需要被容器管理的组件。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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.woniuxy.springIoc.service.impl.UserServiceImpl"></bean>
        <bean id="userController" class="com.woniuxy.springIoc.controller.UserController">
                <property name="userService" ref="userService"></property>
        </bean>
</beans>

注意：id 是组件在容器中的唯一标识，class 是组件在容器的类的全路径。

7、测试。

图文流程

创建好Maven项目之后，导入依赖关系。

    <!--导入spring框架的依赖包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

编写JavaBean

package com.woniuxy.bean;
import java.io.Serializable;
public class StudentBean implements Serializable {
    private Long id;
    private String stuName;
    private Integer age;
    /**
     * 0 女
     * 1 男
     * -1 未知
     */
    private Integer gender;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "StudentBean{" +
                "id=" + id +
                ", stuName='" + stuName + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

编写各层接口

(1)表现层没有接口;

(2)业务层有接口： IStudentService;

(3)持久层有接口: StudentMapper;

(4)并在接口中，提供对应的抽象方法;

业务层（IStudentService）：

package com.woniuxy.service;
import com.woniuxy.bean.StudentBean;
import java.util.List;
public interface IStudentService {
    /**
     * 新增学生
     * @param studentBean
     */
    void saveStudentBean(StudentBean studentBean);
    /**
     * 修改学生
     * @param studentBean
     */
    void updateStudentBean(StudentBean studentBean);
    /**
     * 删除学生
     * @param studentBean
     */
    void deleteStudentBean(StudentBean studentBean);
    /**
     * 根据ID查询学生
     * @param id
     * @return
     */
    StudentBean getOne(Long id);
    /**
     * 根据学生名称，模糊查询所有的学生信息
     * @param studentName
     * @return
     */
    List<StudentBean> findAllByStuName(String studentName);

持久层（StudentMapper.java）：

package com.woniuxy.mapper;
import com.woniuxy.bean.StudentBean;
import java.util.List;
public interface StudentMapper {
    /**
     * 新增学生
     * @param studentBean
     */
    void saveStudentBean(StudentBean studentBean);
    /**
     * 修改学生
     * @param studentBean
     */
    void updateStudentBean(StudentBean studentBean);
    /**
     * 删除学生
     * @param studentBean
     */
    void deleteStudentBean(StudentBean studentBean);
    /**
     * 根据ID查询学生
     * @param id
     * @return
     */
    StudentBean getOne(Long id);
    /**
     * 根据学生名称，模糊查询所有的学生信息
     * @param studentName
     * @return
     */
    List<StudentBean> findAllByStuName(String studentName);
}

持久层（StudentMapper.java）：

package com.woniuxy.mapper;
import com.woniuxy.bean.StudentBean;
import java.util.List;
public interface StudentMapper {
    /**
     * 新增学生
     * @param studentBean
     */
    void saveStudentBean(StudentBean studentBean);
    /**
     * 修改学生
     * @param studentBean
     */
    void updateStudentBean(StudentBean studentBean);
    /**
     * 删除学生
     * @param studentBean
     */
    void deleteStudentBean(StudentBean studentBean);
    /**
     * 根据ID查询学生
     * @param id
     * @return
     */
    StudentBean getOne(Long id);
    /**
     * 根据学生名称，模糊查询所有的学生信息
     * @param studentName
     * @return
     */
    List<StudentBean> findAllByStuName(String studentName);
}

分层实现各层接口：

–针对StudentMapper 无非就编写StudentMapper.xml
针对于IStudentService 无非编写一个它的实现类StudentServiceImpl。

——StudentServiceImpl.java

package com.woniuxy.service.impl;
import com.woniuxy.bean.StudentBean;
import com.woniuxy.service.IStudentService;
import java.util.List;
public class StudentServiceImpl implements IStudentService {
    @Override
    public void saveStudentBean(StudentBean studentBean) {
    }
    @Override
    public void updateStudentBean(StudentBean studentBean) {
    }
    @Override
    public void deleteStudentBean(StudentBean studentBean) {
    }
    @Override
    public StudentBean getOne(Long id) {
        return null;
    }
    @Override
    public List<StudentBean> findAllByStuName(String studentName) {
        return null;
    }
}

——将实现类交给Spring容器

——将实现类交由Spring容器进行管理

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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">
    <!--将实现类，交给Spring容器来进行管理，并定义它的标识为：studentServiceImpl-->
    <bean id="studentServiceImpl"
          class="com.woniuxy.service.impl.StudentServiceImpl"></bean>
</beans>

——测试

package com.woniuxy.service.impl;
import com.woniuxy.service.IStudentService;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import static org.junit.Assert.*;
public class StudentServiceImplTest {
    /**
     * 创建容器对象
     */
    private ApplicationContext context;
    private IStudentService studentService;
    @Before
    public void setUp() throws Exception {
        context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        studentService = (IStudentService) context.getBean("studentServiceImpl");
        System.out.println(context.getBean("studentServiceImpl") == context.getBean("studentServiceImpl") );
    }
    @Test
    public void saveStudentBean() {
        System.out.println(studentService);
    }
    @Test
    public void updateStudentBean() {
    }
    @Test
    public void deleteStudentBean() {
    }
    @Test
    public void getOne() {
    }
    @Test
    public void findAllByStuName() {
    }
}

SpringIOC

——Spring 框架可以帮助我们管理组件，减少程序员的任务量。

IOC Inversion Of Control（控制反转）（面试题）

——如果没有Spring 容器，程序在使用某些组件的实例的时候，需要自己创建，也就是创建组件实例的控制权是一种 “主动关系” ，但是有了 Spring 容器之后，现在就是由容器来创建，创建好之后，再传递给我们。程序现在创建对象的权利，由之前的主动变成了被动：被动接受。

控制反转的好处

1、降低程序之间的耦合度，由容器帮我们松散了组件之间的耦合关系。

2、可以让我们真正做到：面向抽象编程。（依赖倒置原则）

注意：正式靠这种反转机制，Spring容器才可以做到，“松散程序之间的耦合”；

DI Dependency Injection（依赖注入）（面试题）

DI 和IOC 实际上是同一个东西，没有区别，只是在各自的描述不一样。

依赖注入（面试题）

——在没有Spring 容器的时候，程序在完成某项业务时，需要直接依赖某一个实例。在有了Spring 容器之后，依赖关系由直接依赖实例，变成依赖容器，让容器去创建实例，并将实例重新注入到程序的过程。

IOC 和 DI 的区别（面试题）

——实际上没有区别，只是关注点不一样，IOC 关注的是创建对象的控制权，（由主动创建变成了被动接受），DI关注的是依赖关系（由直接依赖对象，变成了依赖 Spring 容器）。

容器将实例传递给程序的两种方式

1、设值注入

——实际上就是指，让你提供setter（）方法，由Spring 容器调用该方法，将容器中的实例注入到程序中来。

package com.woniuxy.controller;
import com.woniuxy.bean.StudentBean;
import com.woniuxy.service.IStudentService;
import com.woniuxy.service.impl.StudentServiceImpl;
public class StudentController {
    private IStudentService studentService;
    public void setStudentService(IStudentService studentService) {
        this.studentService = studentService;
    }
    /**
     * 保存学生
     * @param studentBean
     */
    public void saveStudentBean(StudentBean studentBean){
        studentService.saveStudentBean(studentBean);
    }
}

具体操作方式：

（1）给属性提供setter（）；

（2）在spring容器的配置文件中，使用property标记完成组件之间的装配。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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">
    <!--将实现类，交给Spring容器来进行管理，并定义它的标识为：studentServiceImpl-->
    <bean id="studentServiceImpl"
          class="com.woniuxy.service.impl.StudentServiceImpl"></bean>
    <bean id="studentController" class="com.woniuxy.controller.StudentController">
        <!--通过property 调用setter() 完成对组件的装配-->
        <property name="studentService" ref="studentServiceImpl"></property>
    </bean>
</beans>

2、构造注入

——需要程序提供构造器，Spring 容器通过调用构造器的方式，给属性赋值。

具体代码：

（1）在程序中创建一个有参构造器；

package com.woniuxy.controller;
import com.woniuxy.bean.StudentBean;
import com.woniuxy.service.IStudentService;
public class StudentController {
    private IStudentService studentService;
    public StudentController(IStudentService studentService) {
        this.studentService = studentService;
    }
    /**
     * 保存学生
     * @param studentBean
     */
    public void saveStudentBean(StudentBean studentBean){
        studentService.saveStudentBean(studentBean);
    }
}

（2）在Spring 容器的配置文件中，使用constructor-arg 完成构造装配。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<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">
    <!--将实现类，交给Spring容器来进行管理，并定义它的标识为：studentServiceImpl-->
    <bean id="studentServiceImpl"
          class="com.woniuxy.service.impl.StudentServiceImpl"></bean>
    <bean id="studentController" class="com.woniuxy.controller.StudentController">
        <constructor-arg name="studentService" ref="studentServiceImpl"></constructor-arg>
    </bean>
</beans>

3、构造注入和设值注入的区别（面试题）

（1）注入的原理不一样，一个是通过构造器装配，一个是通过setter来装配。

（2）设值注入的注入顺序是：Spring容器先把对象创建出来，然后调用setter（）注入内容；而构造注入是产生对象时，就注入内容。

注意：它们两种没有谁好谁坏，只是使用的场景不一样：

–1：设值注入容易被java程序员接受，

–2：如果对注入的顺序有严格要求，就比较适合构造注入；

–3：如果对创建对象的顺序由要求的话，也比较适合构造注入。

*单例模式：

单例模式：它是23种设计模式的一种，它通常的使用场景：当程序中需要某一个类只具备唯一实例的时候，就可以使用这种模式。

（1）懒汉模式：

package com.woniuxy.bean;
public class Calendar {
    private static Calendar calendar;
    /**
     * 私有构造器
     */
    private Calendar(){}
    /**
     * 懒汉模式
     * @return
     */
    public static Calendar getInstance(){
        if(calendar != null){
            return calendar;
        }else{
           synchronized (Calendar.class){
                   if(calender == null){
                     calendar = new Calendar();
                }
            }
        }
        return calendar;
    }
}

（2）饿汉模式

package com.woniuxy.bean;
public class Calendar {
    private static Calendar calendar = new Calendar();
    /**
     * 私有构造器
     */
    private Calendar(){}
    /**
     * 饿汉模式
     * @return
     */
    public static Calendar getInstance(){
        return calendar;
    }
}

饿汉模式：是在类加载的时候，实例本身就已经产生了！
懒汉模式：是在调用类的方法的方式，才产生实例

饿汉模式，天生就是线程安全的！！

*克隆模式（原型模式）

–克隆模式：以某一个东西为原型，批量产生新的对象的方式

–克隆模式，除了产生新的对象，还会复制对象的数据到新的对象身上；

–克隆模式的适用场景：当一个对象拥有大量的属性，并且属性都有值；现在需要大量的相同类型的对象

–具体实现：需要实现一个Cloneable的接口

package com.woniuxy.bean;
import java.io.Serializable;
public class StudentBean implements Serializable,Cloneable {
    private Long id;
    private String stuName;
    private Integer age;
    /**
     * 0 女
     * 1 男
     * -1 未知
     */
    private Integer gender;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "StudentBean{" +
                "id=" + id +
                ", stuName='" + stuName + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

package com.woniuxy.bean;
import org.junit.Test;
public class StudentBeanTest {
    @Test
    public void testClone(){
        StudentBean studentBean = new StudentBean();
        studentBean.setStuName("黑崎一护");
        studentBean.setAge(18);
        studentBean.setGender(1);
        //克隆
        try {
            StudentBean studentBean1 = (StudentBean) studentBean.clone();
            studentBean1.setStuName("鸣人");
            System.out.println(studentBean);
            System.out.println(studentBean1);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

（1）浅克隆

package com.woniuxy.bean;
import java.io.Serializable;
public class StudentBean implements Serializable,Cloneable {
    private Long id;
    private String stuName;
    private Integer age;
    /**
     * 0 女
     * 1 男
     * -1 未知
     */
    private Integer gender;
    private GirlFriendBean girlFriendBean;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    public GirlFriendBean getGirlFriendBean() {
        return girlFriendBean;
    }
    public void setGirlFriendBean(GirlFriendBean girlFriendBean) {
        this.girlFriendBean = girlFriendBean;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "StudentBean{" +

最低0.47元/天解锁文章

Nobita98

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习记录01

JavaEE概述第一阶段：Java2.0 版本提出Java划分为3大平台;JavaSE：标准版（桌面应用：eclipse ，Navicat，IDEA）JavaME：微型版（移动端应用）JavaEE：企业版（开发大型企业应用）大型企业应用需求1、高并发（能够支持大量的用户同时在线几万-几百万）；2、大数据量（单表的数据可能都达到几千万）；3、支持分布式事务；4、支持集群，支持负载均衡；注意：单台的tomcat 在单位时间1s内，能支持0-500个并发请求；需要的技术轻量级框架
复制链接

扫一扫