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()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
volatile关键字
- volatile关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。把数据变成一个线程共享数据。
- 相比较synchronized来说是一种轻量级的同步策略。
- 缺点：
volatile不具备互斥锁；
volatile不能保证变量的原子性；
ConcurrentHashMap锁分段机制
- java.util .concurrent包提供了多种并发容器类来改进同步容器的性能
- ConcurrentHashMap同步容器类是一个线程安全的哈希表，内部采用“锁分段”机制替代HashTable的独占锁，提高性能
6383
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
