入职了，在工作了。我不知道该写些什么才能表达此刻的心情，激情无限，有时候觉得写代码挺爽的，按照你的思想，意愿，写出自己的风格，性情。
有时心情十分平静，工作，什么都不用想，可有时又有许多忧愁，
没事的时候写写博客，虽然大多都是copy的，但还是对我有帮助的，写了一遍，就有了印象。
计算机也蛮好玩的，玩玩linux,看看那些底层，知晓下原理，玩玩服务器，累了就看看视频做做项目，
日记
走过不少路，
危机感，不思进取，安于现状而不去改变。
oracle语句的分类
oracle语句主要分以下四类
DML(Data Mannipulation Language)数据操纵语言：查询、操纵数据表资料行
- SELECT : 检索数据库表或视图数据
- INSERT : 将数据行新增至数据库表或视图中
- UPDATE : 修改表或视图中现有的数据行
- DELETE : 删除表或视图中现有的数据行
注意：DML语句不会自动提交事务！
DDL(Data Definition Language)数据定义语言：建立、修改、删除数据库中数据表对象
- CREATE TABLE : 创建表
- ALTER TABLE : 修改表
- DROP TABLE : 删除表
注意：DLL语句会自动提交事务！所以：DML语句事务提交之前可以回滚，DDL语句不能回滚事务
DCL(Data Control Language)数据控制语言：用于执行权限授予与收回操作
- GRANT : 给用户或角色授予权限
- REVOKE : 收回用户或角色的所有权限
注：DCL[Data Control language,数据控制语言] 一般包括事务控制语句(TCS)、会话控制语句(SCT)、系统控制语句(SCT)。
TCL(Transactional Control Language)事物控制语言：维护数据的一致性
- COMMIT :提交已经进行的数据库改变
- ROLLBACK : 回滚已经进行的数据改变
- SAVEPOINT : 设置保存点，用于部分数据改变的取消
oracle事务
事务隔离
- 一个未提交的事务所做的修改不能被其它事务所看到。只有当事务提交成功后，在该事务之后执行的其它事务才可能看到该事务所做的改变。
- 在该事务提交之前已经执行了一部分而另一部分在该事务提交后执行的剩余部分同样也看不到该事务做出的改变。这是另一个Oracle特性：读一致和快照。
- 在该事务提交同时进行的其它事务同样也看不到该事务所做的改变
语句级回滚
- 当一个SQL语句在执行期间因为发生的任何错误而中断时，将产生一个“语句级回滚”。该回滚的后果就像这个SQL语句根本没有执行过一样。
- 注意回滚是发生在“执行”阶段的，如果是在SQL语句的解析阶段因为语法问题而无法执行。因为没有产生任何影响而不会出现“回滚”。
Oracle事务控制的分割
如果一个事务中包含了DML语句和DDL语句，那么该事务会被分解成多个事务。首先在DDL之前的所有DML语句会被作为一个事务而一次性提交。然后Oracle会为这个DDL创建一个新的，单语句的事务。如果DDL语句执行失败了，那么DML事务依然成功。 每个DDL语句单独成为一个事务，也就是说DDL语句不能回退。
不同情况下的Oracle事务控制
请注意：用户从Oracle服务器断开连接和用户进程强行中断的后果是不同的。
- 前者典型的例子是Oracle服务器关闭或重启，此时所有未提交事务会被提交。
- 后者典型的例子用户通过进程管理器强行kill掉进程，此时所有未提交事务所做的操作被回滚。
事务提交前要做的事情
Oracle提交一个事务之前，必须做以下几件事情：
- 记住数据被修改前是什么样子的
- 记住数据即将要被改成什么样子
- 记住redo log和undo log的关联
- 将SGA中已读取到内存的数据修改为新的值(此时并未真正保存到数据文件)
其中第一步是通过在undo表空间中记录undo日志来完成的。第二步、第三步是通过向SGA中的redo日志缓冲区写记录来完成的。这样当事务回滚时就可以从redo日志找到对应的undo日志，从而找回之前的数据
- 要特别注意的是：此时不一定会触发DBWn进程。
- 要特别注意的另一个地方是：第2步记录事务操作的改变是内存中进行的，还未写到磁盘上的redo日志文件
事务提交时所做的事情
- 记录SCN值(System Change Number)
- 将在线重做日志记录(位于SGA的redo日志缓冲区中)持久化到redo日志文件
- Oracle释放资源和锁
- Oracle将事务标记为已结束
注意：只有在commit指令被发出后，才会将SGA中重做日志缓冲区的内容刷新到磁盘的redo日志文件。在LGWR进程执行前，重做日志一直存在于内存中，也被称为在线重做日志。
savepoint回滚和整个事务的回滚
注意当Oracle事务回滚到某个savepoint时，在savepoint之后的所有后续savepoint将失效。但此时Transaction还是活跃且可继续的。这一点不同于整个事务的回滚。
自治事务
从传统上来说，一个事务只有在完整执行成功或回滚之后，才会进行下一个事务。而自治事务允许在一个事务中调用运行另一个事务，被调用事务执行完成后，调用事务继续执行之前未完成的操作直至事务结束
自治事务在被调用后，将和外围事务完全独立。彼此之间并不共享任何资源或者锁，外围事务所有未提交的改变对自治事务来说都是不可见。自治事务提交后外围事务将可以看到改变。
Spring AOP
本文来源于官方文档
Aspect Oriented Programming with Spring 面向切面编程
简介
- 面向切面编程（AOP）弥补面向对象编程（OOP）通过提供思考程序结构的另一种方式。在OOP中模块化的关键单元是类，而在AOP模块为单位的切面。面对关注点，如事务管理跨多个类型和对象切模块化。（这些关注经常被称为横切在AOP文学的关注。）
- Spring的一个关键组件就是AOP框架。虽然Spring IoC容器并不依赖于AOP，这意味着你不需要使用AOP，如果你不想，AOP补充Spring IoC容器提供了非常强大的中间件解决方案。
AOP概念
- 切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
- **连接点(Join point)**： 一个程序，在执行过程中的一个点，如方法的执行或异常的处理。在Spring AOP中，一个连接点总是 代表一个方法的执行。
- **通知(Advice)： 在某个特定的一个方面动作的连接点。不同类型的建议包括“around”，“before”和“after”的建议。（advice 的类型将在下面讨论）。许多AOP框架，包括Spring，Model 中的Advice 作为拦截器，保持了拦截器链周围的连接点(Joinpoint)**。
- **切点(pointcut)**： 每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件
- **代理(AOP proxy)**： AOP框架，以实现Aspect契约（例如通知方法执行等等）创建的对象。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
advice的类型 :
- Before advice: 建议一个执行一个 Join point 之前，但它不具有防止执行流程的连接点（除非它抛出一个异常）的能力。
- After returning advice: 连接点(Join point)正常完成后,方法没有抛出异常后执行
- After throwing advice: advice抛出一个异常时执行。
- After (finally) advice: 结果都会执行，
- Around advice: 环绕通知, 围绕着方法执行
Spring 使用 AspectJ 注解 实现AOP 编程#####、
需导入 aop,aspects 相关jar包
AtithmeticCalculatorImpl.java实现类
package com.dream.apo.impl;
import org.springframework.stereotype.Component;
@Component("atithmeticCalculator1")
public class AtithmeticCalculatorImpl implements AtithmeticCalculator {
@Override
public int add(int i, int j) {
int result=i+j;
return result;
}
@Override
public int sub(int i, int j) {
int result=i-j;
return result;
}
@Override
public int mul(int i, int j) {
int result=i*j;
return result;
}
@Override
public int div(int i, int j) {
int result=i/j;
return result;
}
}
AOP实现代码 LoginAspect.java
package com.dream.apo.impl;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoginAspect {
@Before("execution(public int com.dream.apo.impl.AtithmeticCalculator.*(..) )")
public void beforeMethod(JoinPoint joinPoint){
String methodName=joinPoint.getSignature().getName();
Object []args=joinPoint.getArgs();
System.out.println("the method is "+methodName+"begin with "+Arrays.asList(args));
}
@After("execution(public int com.dream.apo.impl.AtithmeticCalculator.*(..) )")
public void after(JoinPoint joinPoint){
String methodName=joinPoint.getSignature().getName();
System.out.println("the method is "+methodName+" ends ");
}
@AfterReturning(value="execution(public int com.dream.apo.impl.AtithmeticCalculator.*(..) )",
returning="result")
public void afterReturning(JoinPoint joinPoint,Object result){
String methodName=joinPoint.getSignature().getName();
System.out.println("the method is "+methodName+" return ends "+result);
}
@AfterThrowing(value="execution(public int com.dream.apo.impl.AtithmeticCalculator.*(..) )",
throwing="ex")
public void afterThrowing(JoinPoint joinPoint,Exception ex){
String methodName=joinPoint.getSignature().getName();
System.out.println("the method is "+methodName+" occurs exception "+ex);
}
}
主方法
package com.dream.apo.impl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
AtithmeticCalculator act= (AtithmeticCalculator) ac.getBean("atithmeticCalculator1");
int result=act.add(3, 4);
System.out.println("result="+result);
result=act.div(6, 1);
System.out.println("result="+result);
}
}
applicationContext.xml 配置文件
<context:component-scan base-package="com.dream.apo.impl"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
Spring入门
Spring入门
Spring简介
- Spring 是一个开源框架.
- Spring 为简化企业级应用开发而生. 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能.
- Spring 是一个 IOC(DI) 和 AOP 容器框架
Spring特性
- 轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API
- 依赖注入(DI — dependency injection、IOC)
- 面向切面编程(AOP — aspect oriented programming)
- 容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
- 框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
- 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）
搭建spring开发环境
需要导入以下jar 包
commons-logging.jar
spring-beans-4.2.1.RELEASE.jar
spring-context-4.2.1.RELEASE.jar
spring-core-4.2.1.RELEASE.jar
spring-expression-4.2.1.RELEASE.jar
加这么多就足够了，如果还需要其它功能，请加入其它的jar包
内容提要
IOC & DI 概述
- IOC(Inversion of Control)：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式
- DI(Dependency Injection) — IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接
配置bean
- 配置形式：基于 XML 文件的方式；基于注解的方式
- Bean 的配置方式：通过全类名（反射）、通过工厂方法（静态工厂方法 & 实例工厂方法）、FactoryBean
- IOC 容器 BeanFactory & ApplicationContext 概述
- 依赖注入的方式：属性注入；构造器注入
- 注入属性值细节
- 自动转配
- bean 之间的关系：继承；依赖
- bean 的作用域：singleton；prototype；WEB 环境作用域
- 使用外部属性文件
- spEL
- IOC 容器中 Bean 的生命周期
- Spring 4.x 新特性：泛型依赖注入
在xml中配置bean
<!-- 通过全类名的方式配置bean -->
<bean id="dao" class="com.dream.hello.Dao"> </bean>
id:bean的名称，在 IOC 容器中必须是唯一的，若 id 没有指定，Spring 自动将权限定性类名作为 Bean 的名字
依赖注入
属性注入
属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
属性注入使用
元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 子节点指定属性值 属性注入是实际应用中最常用的注入方式
构造方法注入
- 通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
- 构造器注入在
元素里声明属性, 中没有 name 属性
按索引匹配入参：
配置文件:
<bean id="dao" class="com.dream.hello.Dao">
<constructor-arg value="zhangsan" index="0"></constructor-arg>
<constructor-arg value="12" index="1"></constructor-arg>
</bean>
实体类:要有相对应的构造器和set get方法
public Dao(String name, int age) {
this.name = name;
this.age = age;
}
按类型匹配入参
配置文件:
<bean id="dao" class="com.dream.hello.Dao">
<constructor-arg value="zhangsan" type="java.lang.String"></constructor-arg>
<constructor-arg value="12" type="java.lang.Integer"></constructor-arg>
</bean>
实体类:把int改成Integer,
public Dao(String name, Integer age) {
this.name = name;
this.age = age;
}
Spring对JDBC的支持
- 为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架.
- 作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低.
Spring提供了3个模板类
- JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。
- NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。
- SimpleJdbcTemplate：利用Java 5的特性，比如自动装箱、通用（generic）和可变参数列表来简化JDBC模板的使用。
JdbcTemplate主要提供以下4类方法
- execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；
- update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；
- query方法及queryForXXX方法：用于执行查询相关语句；
- call方法：用于执行存储过程、函数相关语句。
JdbcTemplate 的使用
实现代码:
db.properties
url=jdbc\:oracle\:thin\:@localhost\:1521\:orcl
driver=oracle.jdbc.driver.OracleDriver
user=test
password=ztt123456
application.xml
<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${user}"></property>
<property name="password" value="${password}"></property>
<property name="jdbcUrl" value="${url}"></property>
<property name="driverClass" value="${driver}"></property>
</bean>
<!-- 配置 Spirng 的 JdbcTemplate -->
<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
Test.java
测试代码
public class Main extends JdbcDaoSupport{
@Test
public void Test1() {
ApplicationContext context=new ClassPathXmlApplicationContext("application.xml");
Dao bean = (Dao) context.getBean("dao");
bean.method();
}
@Test
public void test1(){
ApplicationContext context=new ClassPathXmlApplicationContext("application.xml");
JdbcTemplate bean = (JdbcTemplate) context.getBean("jdbcTemplate");
System.out.println(bean.toString());
}
@Test
public void test2(){
JdbcTemplate jdbcTemplate2 = getJdbcTemplate();
System.out.println(jdbcTemplate2.toString());
}
}
请自行添加所需jar包和相关配置文件
linux学习(ubuntu)
cd命令
用于切换当前目录，参数是要切换的目录的路径，可以是绝对路径，也可以是相对路径
cd /root/Docements # 切换到目录 /root/Documents
cd ./path # 切换到当前目录下的path目录中 .表示当前目录
cd ../path # 切换到上层目录中的path目录中 ..表示上一层目录
ls命令
1. -l ：列出长数据串，包含文件的属性与权限数据等
2. -a ：列出全部的文件，连同隐藏文件（开头为.的文件）一起列出来（常用）
3. -d ：仅列出目录本身，而不是列出目录的文件数据
4. -h ：将文件容量以较易读的方式（GB，kB等）列出来
5. -R ：连同子目录的内容一起列出（递归列出），等于该目录下的所有文件都会显示出来
上面的命令也可以组合使用
1. ls -l #以长数据串的形式列出当前目录下的数据文件和目录
2. ls -lR #以长数据串的形式列出当前目录下的所有文件
文件命令
创建一文件夹的话可以用mkdir 命令
mkdir /tmp/test
创建文件
touch /tmp/a.txt
删除命令
rm -f /var/log/httpd/access.log
将会强制删除/var/log/httpd/access.log这个文件 ，-f 就是直接强行删除
rm -rf /var/log/httpd/access
将会删除/var/log/httpd/access目录以及其下所有文件、文件夹
注意
使用这个rm -rf的时候一定要格外小心，linux没有回收站的
关机
shutdown -h now
halt
halt -p
-r 表示重启
-h 表示关机
halt命令的"-p" 选项表示终止系统后中断电源（需主板硬件支持）
重启
shutdown -r now
shutdown -r +15 系统将于15分钟后重启
reboot