文章目录
- 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基础程序设计
1章 Java概述及开发环境搭建2
2章 简单的Java程序11
3章 Java基础程序设计16
4章 数组与方法60
// 2部分 Java面向对象程序设计
5章 面向对象(基础篇)88
6章 面向对象(高级篇)170
7章 异常的捕获及处理235
8章 包及访问控制权限252
// 3部分 Java应用程序设计
9章 多线程266 // 这章跳过不看
10章 泛型307
11章 Java常用类库336 // 第二遍再看
12章 Java IO397 // 这章跳过不看
13章 Java类集491
14章 枚举559
15章 Java反射机制577 // 第二遍再看
16章 Annotion609 // 第二遍再看
17章 Java数据库编程630 // 第二遍再看
18章 图形界面693 // 这章跳过不看
19章 Java网络编程785 // 这章跳过不看
20章 Java新IO801 // 这章跳过不看
基本知识列表
- 数据类型(基本数据类型、引用数据类型)
- 流程控制(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;
}
}
面对对象
- 面向过程思想
- 步骤清晰简单,第一步做什么,第二步做什么…
- 面对过程适合处理一些较为简单的问题。
- 面向对象思想
- 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
- 面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
- 三大特征:
- 继承
- 封装
- 多态
- 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!
- 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。
堆与栈的关系
值修改与引用修改
方法可以修改传递引用所对应的变量值(指针),而不能修改传递值调用所对应的变量值(值)
当传递方法参数类型为基本数据类型(数字以及布尔值)时,一个方法是不可能修改一个基本数据类型的参数
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
}
}
值传递:
引用传递:
异常:错误+异常
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已经替我们完成了所有底层抽象操作,并且传入三个对象 ServletConfig、 ServletRequest、 ServletResponse
1.2 Request:
HTTP请求到了Tomcat后,Tomcat通过字符串解析,把各个请求头( Header),请求地址(URL),请求参数( Query String)都封装进了Request对象中。
1.3 Response:
Servlet逻辑处理后得到结果,最终通过 response. write()方法,将结果写入 response内部的缓冲区。 Tomcat会在 servlet处理结束后,拿到response,遍历里面的信息,组装成HTTP响应发给客户端。
使用Servlet API时,并不直接与底层TCP交互,也不需要解析HTTP协议,因为HttpServletRequest
和HttpServletResponse
就已经封装好了请求和响应
SpringMVC:基于 Servlet的 Spring Web 框架,
MVC 是 Model、View 和 Controller 的缩写,分别代表 Web 应用程序中的 3 种职责。
- (Model)模型:用于存储数据以及处理用户请求的业务逻辑。(类,包括业务和数据)
- (View)视图:向控制器提交数据,显示模型中的数据。(页面)
- (Controller)控制器:根据视图提出的请求判断将请求和数据交给哪个模型处理,将处理后的有关结果交给哪个视图更新显示。
spring
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。
控制反转 IoC(Inversion of Control)
在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。
- 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
- 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
- 依赖注入 : 就是利用set方法来进行注入的.
- IOC是一种编程思想,由主动的编程变成被动的接收
// 接口
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();
}
}
面向切面 Aop
OOP:Object Oriented Programming,OOP作为面向对象编程的模式,封装、继承和多态。
AOP:Aspect Oriented Programming,意为:面向切面编程。
对于日志,安全,缓存,事务等代码,它们会重复出现在每个业务方法中。使用OOP,我们很难将这些四处分散的代码模块化
BookService
关心的是自身的核心逻辑,但整个系统还要求关注日志,安全,缓存,事务等功能,这些功能实际上“横跨”多个业务方法,为了实现这些功能,不得不在每个业务方法上重复编写代码
使用AOP,实际上就是让Spring自动为我们创建一个Proxy,使得调用方能无感知地调用指定方法,但运行期却动态“织入”了其他逻辑,因此,AOP本质上就是一个代理模式。
- 横切关注点:跨越应用程序多个模块的方法或功能,与我们业务逻辑无关的,但是需要关注的部
分,就是横切关注点,如日志,安全,缓存,事务
在Java平台上,对于AOP的织入,有3种方式:
- 编译期:在编译时,由编译器把切面调用编译进字节码,这种方式需要定义新的关键字并扩展编译器,AspectJ就扩展了Java编译器,使用关键字aspect来实现织入;
- 类加载器:在目标类被装载到JVM时,通过一个特殊的类加载器,对目标类的字节码重新“增强”;
- 运行期:目标对象和切面都是普通Java类,通过JVM的动态代理功能或者第三方库实现运行期动态织入。
最简单的方式是第三种,Spring的AOP实现就是基于JVM的动态代理。由于JVM的动态代理要求必须实现接口,如果一个普通类没有业务接口,就需要通过CGLIB或者Javassist这些第三方库实现。
使用AOP非常简单,一共需要三步:
- 定义执行方法,并在方法上通过AspectJ的注解告诉Spring应该在何处调用此方法;
- 标记
@Component
和@Aspect
; - 在
@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驱动来实现真正对数据库的访问。
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
整体架构
- 配置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 { // ...... }
- SpringBoot在启动的时候从类路径下的
META-INF/spring.factories
中获取EnableAutoConfiguration
指定的值 - 将这些值作为自动配置类导入容器 , 自动配置类就生效 , 帮我们进行自动配置工作;
- 以前我们需要自动配置的东西,现在springboot帮我们做了
- 整合JavaEE,整体解决方案和自动配置的东西都在
springboot-autoconfigure
的jar包中; - 它会把所有需要导入的组件,以类名的方式返回,这些组件就会被添加到容器中
- 它会给容器中导入非常多的自动配置类 (xxxAutoConfiguration), 就是给容器中导入这个场景需要的所有组件 , 并自动配置,@Configuration(javaConfig) ;
- 有了自动配置类 , 免去了我们手动编写配置注入功能组件等的工作;
run 方法流程实例
配置文件
配置文件的作用 :修改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);
}
}