java内容快速回顾+SSM+SpringBoot简要概述

admin2024-05-15  0

文章目录

  • java基础知识
    • 基本知识列表
    • 面对对象
    • 堆与栈的关系
    • 值修改与引用修改
    • 异常:错误+异常
  • SSM
    • springMVC
      • Servlet
      • SpringMVC:基于 Servlet的 Spring Web 框架,
    • spring
      • 控制反转 IoC(Inversion of Control)
      • 面向切面 Aop
    • Mybatis
      • JDBC
      • Mybatis
  • SpringBoot
      • 快速创建项目
      • 运行原理
        • 启动器 spring-boot-starter
        • 主程序
          • 自动加载配置
          • run 方法流程实例
          • 配置文件

java基础知识

文档地址:https://github.com/name365/Blog-Java?tab=readme-ov-file

// 1部分 Java基础程序设计

1Java概述及开发环境搭建2
2章 简单的Java程序11
3Java基础程序设计16
4章 数组与方法60

// 2部分 Java面向对象程序设计

5章 面向对象(基础篇)88
6章 面向对象(高级篇)170
7章 异常的捕获及处理235
8章 包及访问控制权限252

// 3部分 Java应用程序设计

9章 多线程266 // 这章跳过不看
10章 泛型307
11Java常用类库336 // 第二遍再看
12Java IO397 // 这章跳过不看
13Java类集491
14章 枚举559
15Java反射机制577 // 第二遍再看
16Annotion609 // 第二遍再看
17Java数据库编程630 // 第二遍再看
18章 图形界面693 // 这章跳过不看
19Java网络编程785 // 这章跳过不看
20JavaIO801 // 这章跳过不看

基本知识列表

  • 数据类型(基本数据类型、引用数据类型)
  • 流程控制(if、switch、while)
  • 方法(定义、重载、递归)
  • 数组
  • 类(高内聚低耦合)、接口(契约)、面对对象(继承、封装、多态)
  • 异常
    • 抛出异常
    • 捕获异常
    • 异常处理五个关键字:
      • try、catch、 finally、throw、throws
package org.example;

import java.util.Scanner;
import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        int a = 2;

        int[] list = new int[10];
        int[] myList = {1,2,3,4,6,5};
        list[0]=1;
        Arrays.sort(myList);
        System.out.println(Arrays.toString(myList));

        int added = add(1, 3);
        System.out.println(added);
    }

    public static int add(int a, int b){
        return a+b;
    }

}

面对对象

  • 面向过程思想
    • 步骤清晰简单,第一步做什么,第二步做什么…
    • 面对过程适合处理一些较为简单的问题。
  • 面向对象思想
    • 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
      • 面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
      • 三大特征:
        • 继承
        • 封装
        • 多态
    • 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!

堆与栈的关系

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第1张

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第2张

值修改与引用修改

方法可以修改传递引用所对应的变量值(指针),而不能修改传递值调用所对应的变量值(值)

当传递方法参数类型为基本数据类型(数字以及布尔值)时,一个方法是不可能修改一个基本数据类型的参数

package github.method;

public class HomeWork01 {
    private static int x = 10;

    public static void updataeValue(int value){
        value = 3 * value;
        System.out.println("value的值:" + value);
    }

    public static void main(String[] args) {
        System.out.println("调用前的值:" + x); //10
        updataeValue(x);//30,这个方法结束后,参数变量value不再使用,被回收。
        System.out.println("调用后的值:" + x);//10
    }

}

值传递:

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第3张

引用传递:

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第4张

异常:错误+异常

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第5张

SSM

SSM框架是Spring MVC ,Spring和Mybatis框架的整合,是标准的MVC模式,将整个系统划分为View层,Controller层,Service层,DAO层四层。

  • 使用Spring MVC负责请求的转发和视图管理
  • Spring实现业务对象管理
  • Mybatis作为数据对象的持久化引擎

springMVC

Servlet

参考文档:https://blog.csdn.net/qq_42647903/article/details/109648599

我们如何能通过Web服务器映射的URL访问资源?
- 接收请求
- 处理请求
- 响应请求

* 把接收和响应两个步骤抽取成: Web服务器,
* 但处理请求的逻辑是不同的,抽取出来做成 Servlet,交给程序员自己编写。

1. Servlet是啥?
servlet接口定义的是一套处理网络请求的规范,实现
* 你初始化时要做什么? init()
* 你销毀时要做什么?destroy()
* 你接受到请求时要做什么?————service()
抽象类 HttpServlet 继承Genericservlet,实现service的get、post方法区分; HttpServlet无法知晓子类想干嘛,所以写成抽象类,要求实现doGet()doPost()两个方法,当子类重写该方法,整个业务代码就活了

2. 那请求怎么来到servlet呢?答案是servlet容器。
比如我们最常用的tomcat,必须把servlet部署到一个容器中,不然servlet不会起作用。
    
3. tomcat才是与客户端直接打交道的家伙,Tomcat = web服务器 + Servlet容器
* Tomcat监听了端口
* 请求过来后,根据url等信息,确定要将请求交给哪个servlet去处理
* 调用那个servlet的service方法,service方法返回一个response对象
* tomcat再把这个response返回给客户端。
    
总的来说,Tomcat已经替我们完成了所有底层抽象操作,并且传入三个对象 ServletConfigServletRequestServletResponse
1.2 RequestHTTP请求到了Tomcat后,Tomcat通过字符串解析,把各个请求头( Header),请求地址(URL),请求参数( Query String)都封装进了Request对象中。

1.3 ResponseServlet逻辑处理后得到结果,最终通过 response. write()方法,将结果写入 response内部的缓冲区。 Tomcat会在 servlet处理结束后,拿到response,遍历里面的信息,组装成HTTP响应发给客户端。

使用Servlet API时,并不直接与底层TCP交互,也不需要解析HTTP协议,因为HttpServletRequestHttpServletResponse就已经封装好了请求和响应

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第6张

SpringMVC:基于 Servlet的 Spring Web 框架,

MVC 是 Model、View 和 Controller 的缩写,分别代表 Web 应用程序中的 3 种职责。

  • (Model)模型:用于存储数据以及处理用户请求的业务逻辑。(类,包括业务和数据)
  • (View)视图:向控制器提交数据,显示模型中的数据。(页面)
  • (Controller)控制器:根据视图提出的请求判断将请求和数据交给哪个模型处理,将处理后的有关结果交给哪个视图更新显示。

java内容快速回顾+SSM+SpringBoot简要概述,image.png,第7张

spring

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。

控制反转 IoC(Inversion of Control)

在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
  • 依赖注入 : 就是利用set方法来进行注入的.
  • IOC是一种编程思想,由主动的编程变成被动的接收

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第8张

// 接口
public interface UserDao {
    public void getUser();
}

//接口实现A
public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

//service接口
public interface UserService {
    public void getUser();
}

// 困境:每增加一个 UserDaoImpl,UserServiceImpl代码就需要修改(强耦合)
public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
    //private UserDao userDao = new UserDaoMySqlImpl();
    //private UserDao userDao = new UserDaoOracleImpl();
 
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

// 利用第三方set 去注入实际的实现类,这样就实现了解耦
public class UserServiceImpl implements UserService {
   private UserDao userDao;
   // 利用set实现,依赖注入
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }
 
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第9张

面向切面 Aop

OOP:Object Oriented Programming,OOP作为面向对象编程的模式,封装、继承和多态。

AOP:Aspect Oriented Programming,意为:面向切面编程。

对于日志,安全,缓存,事务等代码,它们会重复出现在每个业务方法中。使用OOP,我们很难将这些四处分散的代码模块化

BookService关心的是自身的核心逻辑,但整个系统还要求关注日志,安全,缓存,事务等功能,这些功能实际上“横跨”多个业务方法,为了实现这些功能,不得不在每个业务方法上重复编写代码

使用AOP,实际上就是让Spring自动为我们创建一个Proxy,使得调用方能无感知地调用指定方法,但运行期却动态“织入”了其他逻辑,因此,AOP本质上就是一个代理模式。

  • 横切关注点:跨越应用程序多个模块的方法或功能,与我们业务逻辑无关的,但是需要关注的部
    分,就是横切关注点,如日志,安全,缓存,事务

java内容快速回顾+SSM+SpringBoot简要概述,img,第10张

在Java平台上,对于AOP的织入,有3种方式:

  1. 编译期:在编译时,由编译器把切面调用编译进字节码,这种方式需要定义新的关键字并扩展编译器,AspectJ就扩展了Java编译器,使用关键字aspect来实现织入;
  2. 类加载器:在目标类被装载到JVM时,通过一个特殊的类加载器,对目标类的字节码重新“增强”;
  3. 运行期:目标对象和切面都是普通Java类,通过JVM的动态代理功能或者第三方库实现运行期动态织入。

最简单的方式是第三种,Spring的AOP实现就是基于JVM的动态代理。由于JVM的动态代理要求必须实现接口,如果一个普通类没有业务接口,就需要通过CGLIB或者Javassist这些第三方库实现。

使用AOP非常简单,一共需要三步:

  1. 定义执行方法,并在方法上通过AspectJ的注解告诉Spring应该在何处调用此方法;
  2. 标记@Component@Aspect
  3. @Configuration类上标注@EnableAspectJAutoProxy
@Aspect
@Component
public class LoggingAspect {
    // 在执行UserService的每个方法前执行:
    @Before("execution(public * com.itranswarp.learnjava.service.UserService.*(..))")
    public void doAccessCheck() {
        System.err.println("[Before] do access check...");
    }

    // 在执行MailService的每个方法前后执行:
    @Around("execution(public * com.itranswarp.learnjava.service.MailService.*(..))")
    public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
        System.err.println("[Around] start " + pjp.getSignature());
        Object retVal = pjp.proceed();
        System.err.println("[Around] done " + pjp.getSignature());
        return retVal;
    }
}

拦截器有以下类型:

  • @Before:这种拦截器先执行拦截代码,再执行目标代码。如果拦截器抛异常,那么目标代码就不执行了;
  • @After:这种拦截器先执行目标代码,再执行拦截器代码。无论目标代码是否抛异常,拦截器代码都会执行;
  • @AfterReturning:和@After不同的是,只有当目标代码正常返回时,才执行拦截器代码;
  • @AfterThrowing:和@After不同的是,只有当目标代码抛出了异常时,才执行拦截器代码;
  • @Around:能完全控制目标代码是否执行,并可以在执行前后、抛异常后执行任意拦截代码,可以说是包含了上面所有功能。

Mybatis

参考文档:https://www.cnblogs.com/diffx/p/10611082.html

JDBC

Java为关系数据库定义了一套标准的访问接口:JDBC(Java Database Connectivity)

使用Java程序访问数据库时,Java代码并不是直接通过TCP连接去访问数据库,而是通过JDBC接口来访问,而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。

java内容快速回顾+SSM+SpringBoot简要概述,在这里插入图片描述,第11张

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JDBCTest {
    public static void main(String[] args) throws Exception {
        Connection connection = null;
        PreparedStatement prepareStatement = null;
        ResultSet rs = null;

        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接
            String url = "jdbc:mysql://127.0.0.1:3306/ssmdemo";
            String user = "root";
            String password = "123456";
            connection = DriverManager.getConnection(url, user, password);
            // 获取statement,preparedStatement
            String sql = "select * from tb_user where id=?";
            prepareStatement = connection.prepareStatement(sql);
            // 设置参数
            prepareStatement.setLong(1, 1l);
            // 执行查询
            rs = prepareStatement.executeQuery();
            // 处理结果集
            while (rs.next()) {
                System.out.println(rs.getString("userName"));
                System.out.println(rs.getString("name"));
                System.out.println(rs.getInt("age"));
                System.out.println(rs.getDate("birthday"));
            }
        } finally {
            // 关闭连接,释放资源
            if (rs != null) {
                rs.close();
            }
            if (prepareStatement != null) {
                prepareStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
}

Mybatis

整体架构

java内容快速回顾+SSM+SpringBoot简要概述,img,第12张

java内容快速回顾+SSM+SpringBoot简要概述,img,第13张

  • 配置mybatis-config.xml 全局的配置文件 (1、数据源,2、外部的mapper)
  • 创建SqlSessionFactory
  • 通过SqlSessionFactory创建SqlSession对象
  • 通过SqlSession操作数据库 CRUD
  • 调用session.commit()提交事务
  • 调用session.close()关闭会话
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class MybatisTest {
   public static void main(String[] args) throws Exception {
      // 指定全局配置文件
      String resource = "mybatis-config.xml";
      // 读取配置文件
      InputStream inputStream = Resources.getResourceAsStream(resource);
      // 构建sqlSessionFactory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      // 获取sqlSession
      SqlSession sqlSession = sqlSessionFactory.openSession();
      try {
         // 操作CRUD,第一个参数:指定statement,规则:命名空间+“.”+statementId
         // 第二个参数:指定传入sql的参数:这里是用户id
         User user = sqlSession.selectOne("MyMapper.selectUser", 1);
         System.out.println(user);
      } finally {
         sqlSession.close();
      }
   }
}

SpringBoot

依赖关系:spring5 -> spring boot > spring cloud

  • Spring 最初利用“工厂模式”(DI)和“代理模式”(AOP)解耦应用组件。
  • 大家觉得挺好用,于是按照这种模式搞了一个 MVC 框架,用于开发 web 应用(SpringMVC)。
  • 然后有发现每次开发都要搞很多依赖,写很多样板代码很麻烦,于是搞了一些懒人整合包,这套就是 Spring Boot

Spring Boot是一个基于 Spring 的框架,旨在简化 Spring 应用的配置和开发过程,通过自动配置和约定大于配置的原则,使开发者能够快速搭建独立、生产级别的应用程序。

Spring Boot 以约定大于配置的核心思想,默认帮我们进行了很多设置,多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置(例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等),Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用

快速创建项目

参考文档:

  • 教程
  • springBoo教程

运行原理

Maven项目,我们一般从pom.xml文件探究起;

启动器 spring-boot-starter
  • 依赖

    <dependency>        								
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    
  • springboot-boot-starter-xxx,说白了就是Springboot的启动场景

  • 比如spring-boot-starter-web,他就会帮我们自动导入web的所有依赖

  • springboot会将所有的功能场景,都变成一个个的启动器

  • 我们要使用什么功能,就只需要找到对应的启动器就好了start

主程序

默认的主启动类

//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
   public static void main(String[] args) {
      //该方法返回一个ConfigurableApplicationContext对象
 	  //参数一:应用入口的类; 参数二:命令行参数 
      SpringApplication.run(SpringbootApplication.class, args);
   }
}
自动加载配置
  • SpringBoot就应该运行这个类的main方法来启动SpringBoot应用;

  • 进入这个注解:可以看到上面还有很多其他注解!

    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(
        excludeFilters = {@Filter(
        type = FilterType.CUSTOM,
        classes = {TypeExcludeFilter.class}
    ), @Filter(
        type = FilterType.CUSTOM,
        classes = {AutoConfigurationExcludeFilter.class}
    )}
    )
    public @interface SpringBootApplication {
        // ......
    }
    
  1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
  2. 将这些值作为自动配置类导入容器 , 自动配置类就生效 , 帮我们进行自动配置工作;
  3. 以前我们需要自动配置的东西,现在springboot帮我们做了
  4. 整合JavaEE,整体解决方案和自动配置的东西都在springboot-autoconfigure的jar包中;
  5. 它会把所有需要导入的组件,以类名的方式返回,这些组件就会被添加到容器中
  6. 它会给容器中导入非常多的自动配置类 (xxxAutoConfiguration), 就是给容器中导入这个场景需要的所有组件 , 并自动配置,@Configuration(javaConfig) ;
  7. 有了自动配置类 , 免去了我们手动编写配置注入功能组件等的工作;
run 方法流程实例

java内容快速回顾+SSM+SpringBoot简要概述,img,第14张

配置文件

配置文件的作用 :修改SpringBoot自动配置的默认值,因为SpringBoot在底层都给我们自动配置好了;

  • yaml文件更强大的地方在于,他可以给我们的实体类直接注入匹配值!
package nuc.ss.pojo;

@Component  //注册bean到容器中
public class Dog {
    private String name;
    private Integer age;
    
    //有参无参构造、get、set方法、toString()方法  
}

@Component //注册bean
public class Dog {
    @Value("阿黄")
    private String name;
    @Value("18")
    private Integer age;
}

@SpringBootTest
class Springboot02ConfigApplicationTests {

    @Autowired
    private Dog dog;

    @Test
    void contextLoads() {
        System.out.println(dog);
    }

}
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明原文出处。如若内容造成侵权/违法违规/事实不符,请联系SD编程学习网:675289112@qq.com进行投诉反馈,一经查实,立即删除!