开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> java程序开发：设计模式、JVM、SSM -> 正文阅读

[Java知识库]java程序开发：设计模式、JVM、SSM

java反射

在这里插入图片描述

设计模式

三大类

创建型：帮助我们创建出一个对象。
单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型：
行为型：

单例模式

单例模式：就是创建出来一个实例。注意：单例类只能有一个实例（对象）；单例类必须自己创建自己的唯一实例；单例类必须提供一个其他对象访问该实例的全局访问点
(1). 通过此类可以创建出对象（实例），有且只有一个对象
(2). 把构造方法私有化，是的外界无法访问我们的构造方法，内部创建一个对象，供外界访问
(3). 提供一个静态的方法，返回本类的一个对象- 饿汉式：上来就创建一个对象。线程安全，调用效率高，不能延时加载。

/**
* 单例模式
* 1. 通过此类可以创建出对象（实例），有且只有一个对象
* 2. 把构造方法私有化，使得外界无法访问我们的构造方法，内部创建一个对象，供外界访问
* 3. 提供一个静态的方法，返回本类的一个对象
*/
public class SingletonDemo{
	//创建单例的一个对象
	privatte static SingletonDemo instance = new SingletonDemo();
	//让构造函数private，这样该类就不会被实例化
	private SingletonDemo(){}
	//获取唯一可用的对象
	public static SingletonDemo getInstance(){
		return instance;
	}
}

懒汉式：上来并不急于创建对象，先判断这个对象存不存在。存在多线程安全问题，需用synchronized同步锁去解决安全问题。线程安全，调用效率不高，可以延时加载。（延时加载即不访问的时候就不加载，什么时候访问什么时候加载）

public class SingletonDemo2{
	private static SingletonDemo2 instance;
	private SingletonDemo2(){};
	public static SingletonDemo2 getInstance(){
		if(null == instance){//判空的时候尽量把null值写在前面
			instance = new DingletonDemo2();
		}
		return instance;
	}
}

多线程和多进程在微观下是串行的（切换速度快），在宏观下并行的。
单例模式的优点：
（1）由于只能生成一个实例，减少了系统性能开销
（2）单例模式可在系统设置全局的访问点，优化共享资源访问。例如可以设置一个单例类，负责所有数据表的映射处理。

工厂模式

工厂模式实现了创建者和调用者的分离，把创建对象的细节隐藏了，不再关注对象是怎么创建的。
分类：简单工厂模式、工厂方法模式、抽象工厂模式

面向对象设计的基本原则：

开闭原则 OCP：对扩展开放，对修改关闭
依赖倒转原则 DIP：要针对接口编程，不要针对实现编程
迪米特法则 LoD：单向依赖，只与直接的朋友通信，避免与陌生人通信。上层依赖下层，下层不依赖上层，即上层改变对下层没有影响。

目的：便于扩展
工厂模式核心本质：
（1）实例化对象，用工厂方法代替new操作；
（2）将选择实现类、创建对象统一管理和控制，从而将调用者跟我们实现类解耦。

简单工厂模式（也叫静态工厂模式）

简单工厂模式（也叫静态工厂模式）：就是工厂类一般是使用静态的方法，通过接收的参数不同来返回不同对象的实例。
不关注对象是怎么创建的，只管拿来用。工厂Factory这个类去给我们创建对象（只有一个工厂来生产），我们在需要使用的地方直接用工厂Factory这个类去调用需要的对象。
性能高，但不满足开闭原则

工厂方法模式

工厂方法模式避免了简单工厂模式不满足开闭原则的缺点
工厂方法模式与简单工厂模式区别在于： 简单工厂模式只有一个工厂类（一个工厂来生产所有东西）；工厂方法模式有一组实现了相同接口的工厂类，每个种类的有一个工厂（比如不同的车辆厂商）
代码结构复杂

简单工厂模式和工厂方法模式

接口复杂度：工厂方法 > 简单工厂
代码复杂度：简单工厂 > 工厂方法
客户端编程难度：工厂方法 > 简单工厂

根据设计理论建议：工厂方法模式。但实际上，一般都用简单工厂模式。

JVM

JVM是运行在操作系统之上的，它与硬件没有直接的交互。 JVM <-> 操作系统 <-> 硬件体系

Class Loader 类加载器： 只负责加载class字节码文件
Execution Engine 执行引擎： 负责解释命令，提交给操作系统，若有错则报错。和操作系统打交道
Native Interface 本地接口： 有虚拟机无法操作的代码，需要本地接口去和本地打交道
Method Srea方法区
方法区被所有线程共享，所有定义的方法的信息都保存在该区域。
静态变量、常量、类信息、运行时常量存储在方法区；
实例变量存储在堆内存中；
每new一个字符串对象，会在堆里放一份，然后在常量池里放一份
栈管运行，堆管存储
PC Regiser 程序计数器： 就是一个指针，指向方法区中的方法字节码（即下一个要执行的指令代码）
Native Method 本地方法栈： 登记本地方法，在执行引擎执行时加载一些本地的库

JVM的内存区域：

栈

栈内存主管java程序的运行，是在线程创建时创建，生命周期跟随线程，线程结束栈内存也就释放。
栈不存在垃圾回收问题，线程一结束该栈也就Over。
基本类型的变量和对象的引用变量都是在函数的栈内存中分配。

栈中的存储

主要存储3类数据：

本地变量： 输入参数、输出参数、方法内的变量
栈操作： 记录出栈、入栈的操作。
栈帧数据： 加粗样式包括类文件、方法等等。每调用一个方法，该方法就如到栈内

栈运行原理

栈中的数据都是以栈帧的形式存在，每执行一个方法都会产生一个栈帧，保存到 栈（后进先出） 的顶部，顶部就是当前的方法，该方法执行完毕后会自动将此栈帧出栈（遇到结束符}就出栈）
比如入栈顺序是21，则出栈顺序是12

JVM优化是优化哪里

可以优化的是堆区和方法区，即由线程共享的区域。

我们电脑中的JAVA JVM：Sun公司的HotSpot

堆

堆使我们主要维护和优化的区域

一个JVM实例只存在一个堆内存，堆得大小是可以调节的。类加载器读取了类文件后，需要把类、方法、常变量放到堆内存中，保存所有引用类型的真实信息，以方便执行器执行
堆内存分为三部分：

Yong新生区：Eden伊甸区、Survivor幸存（0区、1区）区。是类的产生、成长、消亡的区域。
Tenure养老区：用于保存从新生区筛选出来的java对象，一般池对象都在这个区域活跃。 若出现Java heap space Error，则说明虚拟机的堆内存不够。
**OOM内存溢出异常就发生在对内存的养老区。**原因：（1）java虚拟机内存设置不够，设置参数-Xms、-Xmx来调整；（2）代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）
Parmanent永久区：是一个常驻内存区域，用于存放JDK自身所携带的Class，Interface的元数据，也就是运行环境必须的类信息，不会被垃圾回收器处理，关闭JVM才会释放此区域。
若出现PermGen space 错误，说明java虚拟机对永久代Perm内存设置不够。一般出现这种情况是因为程序启动需要加载大量的第三方jar包。

JVM垃圾收集机制

程序内存划分总结

常量池是方法区的一部分
程序内存划分的例子：

public static void main(String[] args){ // 栈最底下压入主方法main()
	int i=1;//基本类型变量存放在栈区
	object obj = new Object();//new的对象Object存放在堆区；obj这个引用放在栈区，并且指向堆中这个对象
	Memory mem = new Memory();//new的对象Memory存放在堆区；mem这个引用放在栈区，并且指向堆中这个对象
	mem.foo(obj);//foo()方法压入栈中，在main()的上边；param这个形参在栈区，存放的是实参obj，因此也指向堆区的Object对象
}

private void foo(Object param){
	string str = param.toString();//基本类型你那个的常量str存放在栈区；jdk1.7里toString()方法会在常量池里开辟一个空间
	System.out.println(str);
}//结束之后foo()方法会从栈中先出栈；然后主方法main()出栈

Spring

Spring是一个开源框架，为简化企业级开发而生。
Spring是一个控制反转IOC（依赖注入DI）和面向切面AOP的容器框架
容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期
组件化：：Spring实现了使用简单的组件配置组合成一个复杂的应用。在Spring中可以使用XML和Java注解组合这些对象
非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API
一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库

Spring模块

Spring的jar包里常用的jar：core核心、context上下文、expression表达式、beans、logging
Spring的核心配置文件：applicationContext.xml

<!--.dtd 文件里写的是限制XML文件可以写什么内容-->
<!--使用bean元素定义一个由IOC容器创建的对象-->
<!--class属性指定用于指定用于创建bean的全类名  -->
<!--id属性指定用于引用bean实例的标识  -->
<bean id="student" class = "com.helloworld.bean.Student">
	<!--使用property子元素为bean的属性赋值  -->
	<property name="studentId" value="10">
	<property name="age" value="18">
</bean>

/**
* 测试Spring的IOC容器创建Student类实例
*/
//（1）创建IOC容器对象
ApplicationContextiocContiner = new ClassPathXmlApplicationContext("helloworld.xml");
//（2）根据id值获取bean实例对象
Student student = (Student)iocContainer.getBean("student");
//（3）打印bean
System.out.println(student);

Spring作用：（1）通过IOC把各个层连接起来；（2）AOP提供事务的支持，比如动态代理
层与层之间的关联主要是靠注解。通过@Autowired把下一层所生成的对象的引用进行注入。比如在Controller层里注入Service层的内容：
@Autowired
private UserService userService;

IOC容器和Bean的配置

IOC和DI

IOC控制反转
DI依赖注入：是IOC的另一种表述方式，即组件以一些预先定义好的方式（例如：setter方法）接受来自容器的资源注入，即通过setter方法给其赋值。DI是对IOC思想的具体实现。
依赖注入的方式：通过bean的setXxx()方法赋值

@Component：说明我这个类要生成一个对象，放到spring容器里。@Component是下面三个注解的一个抽象
.
@Controller
@Service
@Repository

代理模式

静态代理

代理模式参考文献

静态代理的实现内容：

真实角色：真正做事情的人
代理角色：
（1）具有真实角色所具有的功能；
（2）以及真实角色的引用；
（3）对于外界来说所有的工作是代理角色做的，但真正做事情的是通过真实角色的引用去调用真实角色做的；
（4）代理角色会加入自己的方法；
抽象角色：可以是一个抽象类也可以是一个接口；需要真实角色和代理角色共同实现或继承；

AOP 面向切面的编程

核心关注点：和业务相关的称之为核心关注点
横切关注点：和核心业务无关，但对核心业务提供支持的方法。提供一些辅助功能：比如安全性验证、打印日志
AOP常用注解：

@Aspect：告诉spring，这个类是一个切面，是所有辅助方法的一个汇总类，供容器读取
@Before：前置通知
@AfterReturning：方法正常退出时执行
@AfterThrowing：有异常抛出时执行
@After：不管是抛出异常或者正常退出都会执行
@Pointcut：切点

例子：

package com.aspectj.test.advice;
 
import java.util.Arrays;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
 
@Aspect
public class AdviceTest {
    @Around("execution(* com.abc.service.*.many*(..))")//(..)表示任意参数类型；*表示所有
    public Object process(ProceedingJoinPoint point) throws Throwable {
        System.out.println("@Around：执行目标方法之前...");
        //访问目标方法的参数：
        Object[] args = point.getArgs();
        if (args != null && args.length > 0 && args[0].getClass() == String.class) {
            args[0] = "改变后的参数1";
        }
        //用改变后的参数执行目标方法
        Object returnValue = point.proceed(args);
        System.out.println("@Around：执行目标方法之后...");
        System.out.println("@Around：被织入的目标对象为：" + point.getTarget());
        return "原返回值：" + returnValue + "，这是返回结果的后缀";
    }
    
    @Before("execution(* com.abc.service.*.many*(..))")
    public void permissionCheck(JoinPoint point) {
        System.out.println("@Before：模拟权限检查...");
        System.out.println("@Before：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@Before：参数为：" + Arrays.toString(point.getArgs()));
        System.out.println("@Before：被织入的目标对象为：" + point.getTarget());
    }
    
    @AfterReturning(pointcut="execution(* com.abc.service.*.many*(..))", 
        returning="returnValue")
    public void log(JoinPoint point, Object returnValue) {
        System.out.println("@AfterReturning：模拟日志记录功能...");
        System.out.println("@AfterReturning：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@AfterReturning：参数为：" + 
                Arrays.toString(point.getArgs()));
        System.out.println("@AfterReturning：返回值为：" + returnValue);
        System.out.println("@AfterReturning：被织入的目标对象为：" + point.getTarget());
        
    }
    
    @After("execution(* com.abc.service.*.many*(..))")
    public void releaseResource(JoinPoint point) {
        System.out.println("@After：模拟释放资源...");
        System.out.println("@After：目标方法为：" + 
                point.getSignature().getDeclaringTypeName() + 
                "." + point.getSignature().getName());
        System.out.println("@After：参数为：" + Arrays.toString(point.getArgs()));
        System.out.println("@After：被织入的目标对象为：" + point.getTarget());
    }
}

MyBatis

事务管理器

MyBatis有两种事务管理类型：（即type=["JDBC | MANAGED]”）

（1）JDBC：这个配置直接使用JDBC（java数据库连接）的提交和回滚功能，依赖于从数据源获得连接来管理事务的生命周期
（2）MANAGED：这个配置是让容器来管理事务的生命周期。

dataSource元素

dataSource元素使用标准的JDBC数据源接口来配置JDBC连接对象源
MyBatis内置了三种数据源类型：
（1）UNPOOLED：每次需要的时候简单的打开和关闭连接。UNPOOLED数据源的四个配置属性：

driver：指定JDBC驱动器
url：连接数据库实例的JDBC URL
username：登录数据库的用户名
password：登录数据库的密码

（2）POOLED：缓存了JDBC连接对象，用于避免每次创建新的数据库连接时都初始化和进行认证，加快程序响应。

Mapper.mybatis.xml文件

select标签：只能放查询语句
id：唯一标识符
resultType：返回值类型
parameterType：参数类型
#{}占位符
关于SqlSessionFactory和SqlSession两个对象给一个具体的使用过程：参考文献

package com.cn.testIUserService;

import java.io.IOException;
import java.io.InputStream;
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 com.cn.entity.User;

public class MyBatisTest {

    public static void main(String[] args) {
        try {
            //读取mybatis-config.xml文件
            InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
            //初始化mybatis,创建SqlSessionFactory工厂类的实例
            SqlSessionFactory sqlSessionFactory =  new SqlSessionFactoryBuilder().build(resourceAsStream);
            //通过sqlSessionFactory工厂创建session实例
            SqlSession session = sqlSessionFactory.openSession();
            /*
             * 接下来在这里做很多事情,到目前为止,目的已经达到得到了SqlSession对象.通过调用SqlSession里面的方法,
             * 可以测试MyBatis和Dao层接口方法之间的正确性,当然也可以做别的很多事情,在这里就不列举了
             * session可以操作一个一个的语句块
             */
            //插入数据
            User user = new User();
            user.setC_password("123");
            user.setC_username("123");
            user.setC_salt("123");
            //第一个参数为方法的完全限定名:位置信息+映射文件当中的id
            session.insert("com.cn.dao.UserMapping.insertUserInformation", user);
            //提交事务
            session.commit();
            //关闭session
            session.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

现在的参数类型标签一般用parameterType；parameterMap是一个参数的万能接收器，但后期维护起来比较困难，已过时。
配置文件与注解的配合实现过程： 通过配置文件会对配置文件进行扫描；扫描到某一个要用的接口；接口会扫描xml文件类；然后就把实现类（对象）创建出来了，放到IOC容器里；创建出来之后会把该实现类注入到对象（比如userMapper）里；

事务的处理

事务一定是加在Service业务层的；
DAO是和数据库打交道的，没有复合的业务；
加上事务，会让异常的操作进行回滚；

Spring MVC【还需学习】

@RequestMapping(path = {"/xxx"})：请求映射，用来接收处理映射
设计原则：里氏代换原则，尽量和接口打交道，不要和类打交道
springMVC最核心的配置在web.xml，是一个servlet。要配置的有：spring监听器、视图解析器
spring可以处理事务，事务的方式通过AOP面向切面编程搞定。

JAVA 多线程

JUC： 就是java.util .concurrent工具包的简称。这是一个处理线程的工具包

进程与线程

进程：是程序的一次执行，进程是系统进行资源分配和调度的一个独立单位；
线程：是资源调度的基本单位，是程序的执行单元。

线程的状态与操作：

在这里插入图片描述

wait/sleep区别

sleep: sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。sleep让CPU不让锁
wait：线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。