JAVA学习——基础部分4【笔记】

最新推荐文章于 2024-06-27 15:25:28 发布

packdge_black

最新推荐文章于 2024-06-27 15:25:28 发布

阅读量595

点赞数

文章标签： java 学习 spring springMVC

本文链接：https://blog.csdn.net/packdge_black/article/details/126115149

版权

内容来源于：

Spring是什么 (biancheng.net)

Spring核心知识详细教程（已完结）_EasyChill的博客-CSDN博客_spring详细教程

Spring 框架介绍 | 奇客谷教程 💯 (qikegu.com)

本文仅供个人学习使用。

正文：

一、Spring学习

1.1 框架介绍

Spring 有两个核心部分： IoC 和 AOP。这两个都是基于Java的反射机制。

面向切面编程的主要作用是，在不修改源代码的情况下，可以给目标类打补丁，让其执行补丁中的代码。例如，用户类中有个登录方法，现在需要加用户登录日志。使用AOP就不需要修改用户登录方法，只需把日志代码注入到用户登录方法前后，让其执行。日志代码就是“切面”，插入代码的地方（用户类的登录方法）就是“连接点”。

这个后面会具体介绍。

1.2 Spring环境构建：

Spring开发环境搭建 (biancheng.net)
Spring开发环境搭建（Eclipse） - 知乎 (zhihu.com)

安装JDK，安装Eclipse，汉化包安装，spring tools下载安装。

Java Eclipse下载安装教程 (biancheng.net)

接下来我们就要创建一个简单的项目，创建一个项目。

创建一个简单的Spring应用 | 奇客谷教程 💯 (qikegu.com)

第一个Spring程序 (biancheng.net)

Eclipse创建maven项目_qiujingxu的博客-CSDN博客_eclipse创建maven项目

我们按照教程添加相应文件和代码，查看输出结果即可。

1.3 控制反转和依赖注入

IoC容器执行的主要任务:

创建bean实例
根据配置文件装配bean
为bean设置初始化参数
管理bean的生命周期

IoC容器有两种类型:

BeanFactory
ApplicationContext（此接口基于上面的接口，且更为强大，推荐使用）

依赖注入的作用是去除Java类之间的依赖关系，实现松耦合，以便于开发测试。

理解依赖注入（DI – Dependency Injection） | 奇客谷教程 💯 (qikegu.com)

上面链接中的例子讲解的比较清楚。

关于Bean的定义（在XML配置文件中）：

<!-- 定义一个Bean -->
<bean id="..." class="...">
   <!-- bean 配置 -->
</bean>

<!-- App bean -->
<bean id="app" class="App" lazy-init="true"></bean>

ApplicationContext 容器：

ApplicationContext容器是更高级更常用的容器，继承并扩展了BeanFactory的功能。同样ApplicationContext本身是一个Java接口，常用的实现类是：

FileSystemXmlApplicationContext: 通过文件路径加载bean的xml配置文件
ClassPathXmlApplicationContext: 通过类路径加载bean的xml配置文件
WebXmlApplicationContext: 通过web网址加载bean的xml配置文件

举例来分析：

第一步生成工厂对象。加载完指定路径下 bean 配置文件后，利用框架提供的 FileSystemXmlApplicationContext API 去生成工厂 bean。FileSystemXmlApplicationContext 负责生成和初始化所有的对象，比如，所有在 XML bean 配置文件中的 bean。
第二步利用第一步生成的上下文中的 getBean() 方法得到所需要的 bean。这个方法通过配置文件中的 bean ID 来返回一个真正的对象。一旦得到这个对象，就可以利用这个对象来调用任何方法。

二、IDEA+Maven+数据库配置

IDEA中配置maven：

IDEA之maven配置详解 - 创客未来 - 博客园 (cnblogs.com)

实战 Java 第1天：从零开始搭建项目,实现第一个接口（IDEA）_杏子_1024的博客-CSDN博客

配置IDEA后，可以按照上面的博客，完成简单的实现。上面的博客大概有12篇连续的教程，可以简单过一遍。

2.1 maven简单使用

关于目录结构：

src/main/resources

项目的资源，比如说property文件（一种配置文件，主要用于表达配置信息，文件类型为*.properties，格式为文本文件），如springmvc.xml

关于POM：

POM( Project Object Model，项目对象模型 ) 是 Maven 工程的基本工作单元，是一个XML文件，包含了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。

执行任务或目标时，Maven 会在当前目录中查找 POM。它读取 POM，获取所需的配置信息，然后执行目标。

所有 POM 文件都需要 project 元素和三个必需字段：groupId，artifactId，version。

下方链接可以查看POM的标签详解：

Maven POM | 菜鸟教程 (runoob.com)

举例：

比如我们要在pom.xml中添加数据库依赖（mysql 数据库版本需要指定一下）

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
</dependency>
<dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>3.4.0</version>
</dependency>
<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
</dependency>

这样编译器就会自动下载依赖，可以点击编译器弹出的下载直接下；但是如果没有弹框出现，也可右击xml文件，选择maven-Reload Project，自动下载：

关于生命周期：

Maven 有以下三个标准的生命周期：

clean：项目清理的处理
default(或 build)：项目部署的处理
site：项目站点文档创建的处理

创建简单java项目时，可以使用maven来完成构建，使用maven-archetype-quickstart 插件

关于项目文档：

在pom.xml中添加以下（如果没有）：

<project>
  ...
<build>
<pluginManagement>
    <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.3</version>
        </plugin>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>2.7</version>
        </plugin>
    </plugins>
    </pluginManagement>
</build>
 ...
</project>

接着就可以打开项目源目录的文件夹，执行mvn命令：

mvn site

这样maven就会生成文档，在target\site目录下，会有index.html，就可以查看文档。Maven使用一个名为 Doxia的文档处理引擎来创建文档，它能将多种格式的源码读取成一种通用的文档模型。

maven依赖管理：

Maven 依赖管理 | 菜鸟教程 (runoob.com)

2.2 数据库连接驱动类

当我们和数据库进行交互的时候都需要一个与数据库相对应的驱动类来进行数据库的连接。

比如：

com.mysql.cj.jdbc.Driver

载入这个类到JVM之后，在后续的程序中，就可以使用它。

调用Driver中的方法connect，就可以得到一个数据库和应用程序的来连接，而这种调用由第三方：DriverManager来完成，这个第三方被称为驱动管理员，它可以整合需要的东西，配合驱动，得到连接。

DriverManager会跟踪可用的驱动程序，并在数据库和相应的驱动之间建立连接，即获得一个Connection对象。

com.mysql.cj.jdbc.Driver这个驱动类_flybone7的博客-CSDN博客_com.mysql.cj.jdbc.driver

com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver的区别 serverTimezone设定_Java-Basketball的博客-CSDN博客_com.mysql.cj

具体学习（另起一个笔记）

SSM框架合集_哔哩哔哩_bilibili

三、Java学习补充：

3.1 引用传递

如果在程序中，虽然传递了一个String类型的对象，但是结果并没有改变，这是因为字符串的内容一旦声明是不可改变的，改变的只是其内存地址的指向。

3.2

浅谈如何写好一个接口_HyZhan丶丶的博客-CSDN博客_怎么写接口

3.3 子类对象的实例化过程

对于程序，之所以调用父类的构造方法，就是要用父类的构造方法，为父类中的属性初始化，就表示先有父类的实例，然后才有子类实例。

3.4 接口

它是由全局常量和公共的抽象方法所组成；

在接口中的抽象方法必须定义为public访问权限，即便不写，也是public权限，而不是default;

一个抽象类可以实现多个接口；

接口的多继承：在java中一个接口是允许继承抽象类的，但是允许一个接口继承多个接口；

3.5 对象的多态性

样例1（不使用对象多态性实现功能）：

Class A{
    public void fun1() {
        System.out.println("A->public void fun1()");
    }
    public void fun2(){
        this.fun1();
    }
}

Class B extend A{
    public void fun1(){
        System.out.println("B->public void fun1()");
    }
    public void fun3(){
        System.out.println("B->public void fun3()");
    }
}

Class C extend A{
    public void fun1(){
        System.out.println("C->public void fun1()");
    }
    public void fun5(){
        System.out.println("C->public void fun5()");
    }
}

public Class PolDemo{
    public static void main(String[] args) {
        fun(new B());
        fun(new C());
    }
    public static void fun(B b){
        b.fun1();
    }
    public static void fun(C c){
        c.fun1();
    }
}

输出：

B->public void fun1()

C->public void fun1()

但如果A每多一个子类，fun（）方法就要重载一次，如何使用对象多态性完成。

样例2（使用对象多态性）：

Class A{
    public void fun1() {
        System.out.println("A->public void fun1()");
    }
    public void fun2(){
        this.fun1();
    }
}

Class B extend A{
    public void fun1(){
        System.out.println("B->public void fun1()");
    }
    public void fun3(){
        System.out.println("B->public void fun3()");
    }
}

Class C extend A{
    public void fun1(){
        System.out.println("C->public void fun1()");
    }
    public void fun5(){
        System.out.println("C->public void fun5()");
    }
}

public Class PolDemo{
    public static void main(String[] args) {
        fun(new B());  //传递B类实例，产生向上转型
        fun(new C());  //传递C类实例，产生向上转型
    }
    public static void fun(A a){
        a.fun1();
    }
}

在fun（）方法中使用了对象的多态性，所以可以接受任何的子类对象，这样无论子类如何增长，fun（）方法无需改变，因为一旦发生对象的向上转型后，调用的方法一定是被子类覆写过的方法。

3.6 异常

在java中，所有捕获范围小的异常必须放在捕获大的异常之前，否则程序在编译时就会出现错误提示。

使用throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理。而throw是可以直接使用抛出一个异常，抛出时直接抛出异常类的实例化对象即可。

Exception类和RuntimeException区别：