知向谁边
知向谁边

Spring5_学习笔记小结

一、Spring简介

1、简介

  • 2002年，首次推出Spring框架的雏形：interface21框架

  • Spring框架是以interface21框架为基础，经过重新设计、不断丰富内涵，于2004年3月24日发布了1.0正式版

  • Spring理念：使现有技术更加容易使用，整合了现有的技术框架

  • SSH：Struct2 + Spring + Hibernate

  • SSM：SpringMVC + Spring + Mybatis

  • Spring Framework 中文文档

  • spring官方文档

  • Spring官网

  • 官网下载地址

  • GitHub

  • Maven依赖



    org.springframework
    spring-webmvc
    5.2.0.RELEASE



    org.springframework
    spring-jdbc
    5.2.0.RELEASE

2、优点

  • Spring是一个开源的免费的框架（容器）
  • Spring是一个轻量级、非入侵式的框架
  • 控制反转（IOC），面向切面编程（AOP）
  • 支持事务的处理，对框架整合的支持

总结：==Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架==

3、组成

  • Spring---七大核心模块
    image

4、拓展

image

  • Spring Boot

    • 一个快速开发的脚手架
    • 基于SpringBoot可以快速开发单个微服务
    • 约定大于配置

  • Spring Cloud

    • SpringCloud是基于SpringBoot实现

  • Spring弊端：配置繁琐

二、IOC理论

1、 IOC原型

  • 以往的实现步骤
    1. XXX Dao
    2. XXX DaoImpl
    3. XXX Service
    4. XXX ServiceImpl
    5. XXX Servlet
image

存在问题

（1）当Service层调用Dao层时，Dao层会有许多不同的实现类，是根据不同业务而实现的，那么Service层会在调用时出现：选择实现类的问题。
（2）假如Service的实现类，来选择某一个Dao层实现类，由ServiceImpl来创建对应的DaoImpl实例对象，那么ServiceImpl就只能有一个具体的Dao层实现类。
（3）可是当需要使用其他Dao层实现类，我们需要去改变ServiceImpl中的DaoImpl对象
（4）这样程序的耦合性高

控制反转（思想）

  • 假如我们Service层不再实例化一个具体的DaoImpl对象，即程序员不用根据不同的需求而跑到Service层选择不同的DaoImpl类而创建对象

  • 将对象的创建交给更上一层，调用Service层的 Servlet层去确定要使用哪一个DaoImpl类，直接创建并且传入给Service层即可

  • 程序对象创建的主动权，交给了用户。至此，程序员不用管理对象的创建，系统的耦合性降低

  • 左边为：业务层决定调用的对象；右边为：用户层决定让业务层去调用某个对象


    image
  • 控制反转（思想）代码演示：
    • 通过Set注入一个UserDao对象，程序不再具有主动性，而是变成被动的接收对象
public class UserServiceImpl implements UserService {
    //引入Dao层
    private UserDao userDao = null;
    //由创建该对象的实例对象决定使用那一个UserDao
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    //通过Set注入一个UserDao对象，程序不再具有主动性，而是变成被动的接收对象
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

2、IOC本质

控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法。

  • 没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制
  • 控制反转后，将对象的创建转移给第三方：获得依赖对象的方式反转了

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）

3、HelloSpring

image
  • Hello.java
    • 注意：要有无参的构造方法以及参数的set方法
public class Hello {

    String str = null;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}
  • beans.xml
  • Test.java
import com.vigil.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //获取Spring的上下文对象，解析beans.xml文件，生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //对象都由Spring管理，使用的时候直接取出来使用
        //getBean：参数即为spring配置文件中的bean的id
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

这一系列的过程就叫控制反转

  • 控制：控制对象的创建

    • 传统应用程序的对象是由程序本身控制创建
    • 使用Spring后，对象是由Spring来创建

  • 反转：程序本身不创建对象，而变为被动的接收对象

  • 依赖注入：利用set方法来进行注入

  • IOC是一种编程思想，是由主动的编程编程被动的接收

  • 利用Spring，不用在程序中去改动，要实现不同的操作，只需要在xml配置文件中进行修改，所谓IoC：对象由Spring创建、管理、装配

image

4、对User实现的修改

  • UserServiceImpl
public class UserServiceImpl implements UserService {
    //引入Dao层
    private UserDao userDao = null;

//    public UserServiceImpl(UserDao userDao) {
//        this.userDao = userDao;
//    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}
  • beans.xml(ApplicationContext)
  • Test.java
public class Test {
    public static void main(String[] args) {
//        UserService userService = new UserServiceImpl(new UserDaoSqlServerImpl());
//        userService.getUser();
        //获取ApplicationContext：拿到Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //利用容器获得对象
        UserService userService = (UserService) context.getBean("UserService");
        userService.getUser();
    }
}

三、IOC创建对象的方式

  1. 使用无参构造创建对象，这是默认的！
  2. 使用有参构造创建对象
    1、第一种方式：下标赋值
    2、通过类型创建，但不建议使用，影响多态的实现
    3、第三种方式：直接通过参数名来设置
  • 注意：bean的id不可重复
  • 总结：

在配置文件加载的时候，容器中管理的对象就已经初始化了

四、Spring配置

1、别名

2、Bean配置

  • 在 bean 定义本身中，可以使用id属性指定的最多一个名称和name属性中任意数量的其他名称的组合来为 bean 提供多个名称。

3、import

  • 将多个配置文件导入合并为一个

五、依赖注入

1、构造器注入

(1) 使用无参构造创建对象，这是默认的！

(2) 使用有参构造创建对象

  • 1）第一种方式：下标赋值
  • 2）通过类型创建，但不建议使用，影响多态的实现
  • 3）第三种方式：直接通过参数名来设置

2、Set方式注入

  • 依赖注入：Set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中所有的属性，都由容器来注入

【环境搭建】

  1. 复杂类型
public class Address {
    private String address;
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}
  1. 真实对象
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List hobbies;
    private Map care;
    private Set games;
    private String wife;
    private Properties info;
}
  1. beans.xml
  1. 测试类
public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
    }
}
  1. 完善



    
        
    

    
        
        
        
        

        
        
            
                三国演义
                红楼梦
                西游记
                红楼梦
            
        

        
        
            
                听歌
                看电影
                敲代码
                玩游戏
            
        

        
        
            
                
                
            
        

        
        
            
                API
                LOL
                COC
            
        

        
        
            
        

        
        
            
                19120501
                男
                楚名

3、拓展注入

(1) p-namespace ：

使用bean元素的属性(而不是嵌套的元素)来描述协作 Bean 的属性值，或同时使用这两者，相当于set注入

(2) c-namespace

c:命名空间执行与基于构造函数的依赖注入相同的操作，相当于构造器注入

  • 代码实现
  • 测试代码
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = (User) context.getBean("userConstructor");
        System.out.println(user.toString());
  • 注意：
    要加入的一段代码：xml约束
xmlns:c="http://www.springframework.org/schema/c"
xmlns:p="http://www.springframework.org/schema/p"

4、Bean的作用域

Scope Description
singleton (默认)将每个 Spring IoC 容器的单个 bean 定义范围限定为单个对象实例。
prototype 将单个 bean 定义的作用域限定为任意数量的对象实例。
request 将单个 bean 定义的范围限定为单个 HTTP 请求的生命周期。也就是说，每个 HTTP 请求都有一个在单个 bean 定义后面创建的 bean 实例。仅在web的 Spring ApplicationContext中有效。
session 将单个 bean 定义的范围限定为 HTTP Session的生命周期。仅在web的 Spring ApplicationContext上下文中有效。
application 将单个 bean 定义的范围限定为ServletContext的生命周期。仅在web的 Spring ApplicationContext上下文中有效。
websocket 将单个 bean 定义的范围限定为WebSocket的生命周期。仅在web的 Spring ApplicationContext上下文中有效。
  1. 单例模式（Spring默认机制）
  1. 原型模式：每次都从容器中get的时候，都会产生一个新的对象
  1. 其余的 request、session、application、websocket，这些只能在web开发中使用到

六、Bean的自动装配

自动装配模式

Mode Explanation
no (默认)无自动装配。 Bean 引用必须由ref元素定义。对于大型部署，建议不要更改默认设置，因为明确指定协作者可以提供更好的控制和清晰度。在某种程度上，它记录了系统的结构。
byName 按属性名称自动布线。 Spring 寻找与需要自动装配的属性同名的 bean。例如，如果一个 bean 定义被设置为按名称自动装配，并且包含一个master属性(即，它具有setMaster(..)方法)，那么 Spring 将查找一个名为master的 bean 定义并使用它来设置属性。
byType 如果容器中恰好存在一个该属性类型的 bean，则使该属性自动装配。如果存在多个错误，则会引发致命异常，这表明您可能不对该 bean 使用byType自动装配。如果没有匹配的 bean，则什么也不会发生(未设置该属性)。
constructor 类似于byType，但适用于构造函数参数。如果容器中不存在构造函数参数类型的一个 bean，则将引发致命错误。
  • 自动装配：Spring满足bean依赖的一种方式
  • Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种装配的方式

  1. 在xml中显式的配置
  2. 在Java中显式配置
  3. 隐式 的自动装配bean【重要】

1、测试

（1） 环境搭配： 一个人有两个宠物

  • Cat.java
public class Cat {
    public void show() {
        System.out.println("mao~");
    }
}
  • Dog.java
public class Dog {
    public void show() {
        System.out.println("hu~");
    }
}
  • Person.java
public class Person {
    private Cat cat;
    private Dog dog;
    private String name;
}
  • beans.xml
  • Test.java
public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println(person.getName());
        person.getDog().show();
        person.getCat().show();
    }
}

2、ByName自动装配

3、ByType自动装配
  • 小结
    • 使用byName：需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
    • 使用byType：需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

4、使用注解实现自动装配

  1. 导入约束：context
  2. 配置注解的 支持：

1）@Autowired

public @interface Autowired {
    boolean required() default true;
}

直接在属性上使用即可，也可以在set方式上使用
使用 Autowired ，则可以不用编写set方法，前提是：这个自动装配的属性在 IOC（Spring）容器中存在，且符合名字byname

2）@Qualifier

public @interface Qualifier {
    String value() default "";
}

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，可以使用@Qualifier (value = "xxx") 去配合@Autowired的使用，指定唯一的bean对象注入（value是beanid）

3）@Resource

@Resource和@Autowired的区别

  • 都是用来自动装配的，都可以放到属性字段上
  • @Autowired 通过byType的方式实现，而且必须要求这个对象存在，常用
  • @Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现。如果两种方式都无法找到，会报错
  • 执行顺序不同：@Autowired 通过byType的方式实现；@Resource 通过byName方式实现
  1. Test
  • beans.xml
  • Person.java
public class Person {
    @Autowired
    @Qualifier(value = "cat2")
    private Cat cat;
    @Resource(name = "dog")
    private Dog dog;
    private String name;
}

七、使用注解开发

在Spring4后，要使用注解开发，必须要保证 aop包的导入


image

使用注解还需要导入context约束，增加注解的支持

  1. bean

  2. 属性如何注入

//等价于：    
//@Component组件：放在类上，说明这个类被Spring管理了，bean

@Component
public class User {
    private String name = "默认测试";

    public String getName() {
        return name;
    }

    //相当于
    @Value("鱼佬")
    public void setName(String name) {
        this.name = name;
    }
}
  1. 衍生的注解
    @Component有几个衍生作用域，按照mvc分层
  • dao【@Repository】
  • service【@Service】
  • controller【@Controller】

这四个注解功能一致，都是代表将某个类注册到Spring中，装配bean

  1. 自动装配
    1）@Autowired
    直接在属性上使用即可，也可以在set方式上使用
    使用 Autowired ，则可以不用编写set方法，前提是：这个自动装配的属性在 IOC（Spring）容器中存在，且符合名字byname

    2）@Qualifier
    如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，可以使用@Qualifier (value = "xxx") 去配合@Autowired的使用，指定唯一的bean对象注入（value是beanid）

    3）@Resource
    @Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现。如果两种方式都无法找到，会报错

  2. 作用域

@Component
//@Scope("singleton")
@Scope("prototype")
public class User {
}
  1. 小结
  • xml和注解：
    • xml更加万能，适用于任何场合，维护简单方便
    • 注解 维护相对复杂
  • xml 与注解的最佳分配
    • xml用来管理bean
    • 注解只负责属性的注入
  • 必须让注解生效，就需要开启注解的支持

八、使用JavaConfig实现配置

纯Java可以完成Spring的配置
JavaConfig 是Spring的子项目，在Spring 4 之后，他成为了核心功能

使用@Configuration 声明配置类时有两种方法来生成bean

  • 方法一：在配置类中定义一个方法，并使用 @Bean 注解声明

  • 方法二：在类上使用 @Component注解，并在配置类上声明 @ComponentScan("类的路径")，这样会自动扫描 @Component并生成bean

  • 配置文件(配置类）

// 这个也会由Spring容器托管，注册到容器中，因为他本来就是一个@Component
// @Configuration 代表这是一个配置类，相当于applicationContext.xml
@Configuration
@Component("com.vigil.pojo")
//将其他配置文件融合到当前的类中
@Import(com.vigil.config.VigilConfig.class)
public class VigilConfig {

    //注册一个bean，就相当于 bean标签
    //方法名，相当于bean标签中的id属性
    //方法返回值，相当于bean标签的class属性
    @Bean
    public User getUser() {
        return new User();//返回要注入的bean对象
    }

}
  • 实体类
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("鱼佬")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}
  • Test
public class Test {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做，就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(VigilConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }
}

九、代理模式

代理模式是：SpringAOP的底层（面向切面编程）

  • 代理分类 （核心：多态）
    • 静态代理
    • 动态代理

1、静态代理

1）角色分析

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，一般会有附属的操作
  • 客户：访问代理对象的人

2）演示住房中介

代码步骤：

  • 接口（出租者）
public interface Leaser {
    public abstract void lease();
}
  • 真实角色（房东）
public class Landlord implements Leaser {
    public void lease() {
        System.out.println("I have a room to lease");
    }
}
  • 代理角色（出租房屋中介）
public class RentalAgent implements Leaser {

    private Leaser landlord;//中介聚合多个房东:Leaser[]

    public RentalAgent() {
    }
    public RentalAgent(Leaser landlord) {
        this.landlord = landlord;
    }

    public void setLandlord(Leaser landlord) {
        this.landlord = landlord;
    }

    public void lease() {
        //调用用户需要的房子，的房东
        landlord.lease();
        //帮助房东完成租房合同的签写
        contract();
        //帮助房东收取租金
        rent();
    }

    // 签写租凭合同
    public void contract() {
        System.out.println("to sign a contract");
    }
    // 收取租金
    public void rent() {
        System.out.println("delivery of the rent");
    }
}
  • 客户（租房者）：访问代理角色
public class Lessee {
    public static void main(String[] args) {
        //租房找中介
        RentalAgent agent = new RentalAgent();
        //看中了某个房子
        //让中介去联系这个房东，是否能租房，不需要客户去联系，客户看房间就行
        agent.setLandlord(new Landlord());
        agent.lease();
    }
}

静态代理模式的好处

  • 可以使真实角色的操作更加纯粹，不用关心公共业务
  • 公共业务就交给代理角色，实现业务分工
  • 公共业务发生拓展时，方便集中管理

缺点

  • 一个真实角色就会产生一个代理角色，代码量翻倍、开发效率变低

2、动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的
  • 动态代理分为两大类：基于接口的动态代理、基于类的动态代理
    • 基于接口 --- JDK动态代理
    • 基于类：cgilb
    • Java字节码实现：javasist

JDK动态代理 两个重要的两个类

  • Proxy：代理
  • InvocationHandler：调用处理程序

测试例子

1）角色分析

  • 抽象角色：一般会使用接口或者抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，一般会有附属的操作
  • 客户：访问代理对象的人

2）演示住房中介

动态代理的代码步骤：

  • 出租者接口
public interface Leaser {  
    public abstract void lease();
}
  • 出租者实例：房东
public class Landlord implements Leaser {
    public void lease() {
        System.out.println("I have a room to lease");
    }
}
  • 出租者代理：出租中介（与静态代理最不同的地方）
    注意：实现了InvocationHandler 接口
    要有要被代理的接口的注入
    要有得到代理类的方法，也就是调用了Proxy.newProxyInstance() 得到一个代理类
    因为继承了Invocation，所以invoke() 方法是要实现的
    在invoke() 方法里，要调用传入的method对象的invoke() 方法
//自动生成代理类，要实现接口Invocation
public class ProxyInvocationHandler implements InvocationHandler {

    // 1.被代理的接口
    private Object target;

    // 2.注入要代理的接口实现类实例对象
    public void setTarget(Object target) {
        this.target = target;
    }

    // 3.生成代理类：指定由指定的类装入器定义的代理类的指定调用处理程序的代理实例，并实现指定的接口
    public Object getProxy() {
        //Proxy创建动态代理类的实例提供了静态方法，也是所有动态代理类的父类的方法创建
        // this.getClass().getClassLoader()：loader的类装载器来定义代理类
        // target.getClass().getInterfaces()：interfaces -为代理类实现的接口列表
        // this：InvocationHandler -调用处理程序调度方法调用
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    // 4.处理代理类实例，返回结果
    // 在代理实例上处理方法调用，并返回结果。
    // 当在与它关联的代理实例上调用方法时，该方法将在调用处理程序上调用此方法。
    //  参数:
    //proxy -代理实例，调用的方法
    //对接口方法的调用相应的 method代理实例的 方法实例。声明类的 方法对象将接口的方法声明，这可能是一个超接口代理接口，代理类继承的方法。
    //args -包含在方法上通过代理实例调用的实参的值对象的数组，或 null如果接口方法不需要参数。原始类型的实参是包裹在适当的原始包装类的实例，如 java.lang.Integer或 java.lang.Boolean。
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，使用反射机制
        Object result = method.invoke(target, args);
        contract();
        rent();
        return null;
    }

    // 签写租凭合同
    public void contract() {
        System.out.println("to sign a contract");
    }
    // 收取租金
    public void rent() {
        System.out.println("delivery of the rent");
    }
}
  • 用户
    注意：要有一个被代理的对象，然后注入给代理角色处理类，再得到一个被代理的代理实例，最后才能调用代理实例的方法
public class Lessee {
    public static void main(String[] args) {
        //真实角色
        Leaser landlord = new Landlord();

        //代理角色处理类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        //通过调用程序处理角色，来处理将要被调用的接口（被代理的接口）
        pih.setTarget(landlord);//设置要代理的对象

        Object obj;
        if((obj = pih.getProxy()) instanceof Leaser) {
            ((Leaser)(obj)).lease();
        }
    }
}

动态代理模式的好处

  • 可以使真实角色的操作更加纯粹，不用关心公共业务
  • 公共业务就交给代理角色，实现业务分工
  • 公共业务发生拓展时，方便集中管理
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务

十、AOP

1、什么是AOP

1）AOP （Aspect Oriented Programming）：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
2）AOP 是 OOP 的延续，是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
3）利用AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率


image

2、AOP 在Spring中的作用

提供声明式事务；允许用户自定义切面

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是：与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如：日志，安全，缓存，事务等
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。是一个类
  • 通知（Advice）：切面必须要完成的工作。是类中的方法
  • 目标（Target）：被统治的对象
  • 代理（Proxy）：向目标对象应用通知之后创建的对象
  • 切入点（PointCut）：切面通知 执行的”地点“的定义
  • 连接点（JointPoint）：与切入点匹配的执行点
image

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice：

通知类型 连接点 实现接口
前置通知 方法前 org.springframework.aop.MethodBeforeAdvice
后置通知 方法后 org.springframework.aop.AfterReturningAdvice
环绕通知 方法前后 org.aopalliance.intercept.MethodInterceptor
异常抛出通知 方法抛出异常 org.springframework.aop.ThrowsAdvice
引介通知 类中增加新的方法属性 org.springframework.aop.IntroductionInterceptor

即 AOP 在不改变原有代码的情况下，去增加新的功能

3、使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包



    org.aspectj
    aspectjweaver
    1.9.4

(1) 使用Spring的API接口【主要SpringAPI接口实现】

  • UserService
public interface UserService {
    public void add();
    public void update();
    public void delete();
    public void query();
}
  • UserServiceImpl
public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void update() {
        System.out.println("修改了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void query() {
        System.out.println("查询了一个用户");
    }
}
  • Log 实现 MethodBeforeAdvice 接口
public class Log implements MethodBeforeAdvice {
    //method： 要执行的目标对象的方法
    //args： 参数
    //target： 目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass() + "的" + method.getName() + "方法被执行了");
    }
}
  • AfterLog 实现 AfterReturningAdvice 接口
public class AfterLog implements AfterReturningAdvice {
    //returnValue：返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法，返回结果为：" + returnValue);
    }
}
  • applicationContext.xml
  • Test
public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //十分注意的地方：动态代理----->代理接口
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

(2) 自定义类来实现AOP【主要切面定义】

  • UserService
  • UserServiceImpl
  • MyLog
public class MyLog {
    public void before() {
        System.out.println("======方法执行前======");
    }
    public void after() {
        System.out.println("======方法执行后======");
    }
}
  • applicationContext.xml
  • Test
public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理：代理接口
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}
  • 两种方式小结

方式一：使用原生Spring API接口 配置文件里只说明用哪几个通知，根据类的定义（实现）去分配具体的功能（before/after)
方式二：自定义类 配置文件里说明切面类的某个方法是做什么的，这样就不用限制类本身性质了
十分注意的地方：动态代理----->代理接口，那么我们传入的是接口，得到是接口实现的实例化对象

(3) 使用注解实现AOP

  • UserService
  • UserServiceImpl
  • AnnotationPointCut.java
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.vigil.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("方法执行前");
    }

    @After("execution(* com.vigil.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("方法执行后");
    }

    //在环绕增强中，可以给定一个参数，代表要获取处理切入的点
    @Around("execution(* com.vigil.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("==环绕前==");

        Signature signature = joinPoint.getSignature();//获得签名
        System.out.println("signature" + signature);

        //执行方法
        Object proceed = joinPoint.proceed();

        System.out.println("==环绕后==");
        System.out.println(proceed);
    }
}
  • applicationContext.xml
  • Test.java
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理：代理接口
        UserService userService = (UserService) context.getBean("userService");
        userService.update();
    }

十一、Spring整合Mybatis

步骤：

  1. 导入相关的包
    • junit
    • mybatis
    • mysql数据库
    • spring相关
    • aop织入
    • mybatis-spring【new】
    
        
            junit
            junit
            4.12
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
            org.mybatis
            mybatis
            3.5.2
        
        
            org.springframework
            spring-webmvc
            5.1.9.RELEASE
        
        
        
            org.springframework
            spring-jdbc
            5.1.9.RELEASE
        
        
        
            org.aspectj
            aspectjweaver
            1.8.13
        
        
        
            org.mybatis
            mybatis-spring
            2.0.2
  1. 编写配置文件
  2. 测试

1、回忆mybatis

  1. 编写实体类
  2. 编写核心配置文件
  3. 编写接口
  4. 编写接口对应的Mapper.xml
  5. 在核心配置文件中注册Mapper.xml
  6. 测试

2、整合Mybatis方式一

官方文档：mybatis-spring

  1. 编写数据源配置
  1. sqlSessionFactory
  1. sqlSessionTemplate
image

前三个配置在一个spring.xml 文件中（作为一个工具配置），实现获得数据源、sqlSessionFactory、sqlSession这三类资源的配置文件

  1. 需要给接口加实现类【】
public class UserMapperImpl implements UserMapper {
    // 在原来所有的操作：都使用sqlSession来执行
    // 而现在都使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    public List getUserList() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUserList();
    }
}
  1. 将实现类注入Spring中

在Spring总配置文件applicationContext.xml 中 import 上面配置资源的xml，注入该实现类
  1. 测试（获得Spring容器，获取bean，调用方法）
public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper",UserMapper.class);
        List userList = userMapper.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
    }

3、整合Mybatis方式二

  • 实现类

继承SqlSessionDaoSupport，直接获取SqlSession的对象

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List getUserList() {
        return getSqlSession().getMapper(UserMapper.class).getUserList();
    }
}
  • 注入spring
  • 测试

4、总结工具配置

十二、声明式事务

1、事务

  • 要么都成功要么都失败
  • ACID原则：
    • 原子性
    • 一致性
    • 隔离性
    • 持久性

2、Spring中的事务管理

mybatis-spring:事务

  • 编程式事务：需要在代码中，进行事务的管理
  • 声明式式事务：AOP
    • 需要导入的包
    
        
            junit
            junit
            4.12
        
        
            mysql
            mysql-connector-java
            5.1.47
        
        
            org.mybatis
            mybatis
            3.5.2
        
        
            org.springframework
            spring-webmvc
            5.1.9.RELEASE
        
        
        
            org.springframework
            spring-jdbc
            5.1.9.RELEASE
        
        
            org.aspectj
            aspectjweaver
            1.8.13
        

        
        
            org.mybatis
            mybatis-spring
            2.0.2
  • 配置文件

你可能感兴趣的:(Spring5_学习笔记小结)

  • 2024年HarmonyOS鸿蒙最新鸿蒙应用开发当前支持的颜色枚举值(2)，2024年最新社招面试题目 2401_84850323 程序员鸿蒙面试学习
    深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新需要这份系统化的资料的朋
  • 侯捷 C++ 课程学习笔记：C++常用标准库 Three～stone c++学习笔记
    标准库#include万能头是一个简写方式，用来一次性包含C++标准库中的许多常用部分，比如输入输出流（iostream）、算法（algorithm）、向量（vector）、列表（list）、队列（queue）、栈（stack）、映射（map）、集合（set）等。使用它可以让程序员在编写解决特定问题的代码时，不必一一列出所需的所有头文件，简化了代码的编写过程。在实际的工程项目或更专业的编程实践中，
  • Node.js和webpack入门-个人学习笔记 ksmswq node.jswebpack学习
    Node.js-入门Node.js基础概念Node.js是一个跨平台JavaScript运行环境，是开发者可以搭建服务器端的JavaStript应用程序。作用1.编写服务端程序2.编写数据接口，提供网页浏览资源等等3.实现“前端工程化”，为Vue和React等框架做铺垫前端工程化-概念开发项目直到上线，过程中集成的所有工具和技术。（Node.js是前端工程化的基础（因为Node.js可以主动读取前
  • Node.js入门(学习笔记) 唐小艾 学习笔记node.js
    文章目录简介NodeJS下载安装下载安装NodeJS与WebStorm整合JS文件运行CommonJS规范模块模块化定义模块引用模块标识node中的对象globalexports和module.exports属性方法引用包packageNPM(NodePackageManager)NPM命令NPM包引用NPM注意下载速度慢Nodejs核心模块Buffer模块buffer类方法buffer实例的属性
  • Golang学习笔记_49——解释器模式 LuckyLay Golang学习笔记golang学习笔记解释器模式设计模式
    Golang学习笔记_46——状态模式Golang学习笔记_47——访问者模式Golang学习笔记_48——中介者模式文章目录一、核心概念1.定义2.解决的问题3.核心角色4.类图二、特点分析三、适用场景1.金融公式引擎2.智能合约解析3.业务规则引擎四、Go语言实现示例完整实现代码执行结果五、高级应用1.表达式缓存优化2.并行解释器六、与其他模式对比七、实现建议八、典型应用一、核心概念1.定义解
  • 前端（vue)学习笔记（CLASS 4）：组件组成部分与通信 肥肠可耐的西西公主 vue.js前端学习
    1、组件的三大组成部分（结构/样式/逻辑）注意点：1、结构只能有一个根元素2、全局样式（默认），影响所有组件；局部样式，scoped下样式，只作用于当前组件3、el根实例独有，data是一个函数，其他配置项一致样式注意点：默认情况下，写在组件中的样式会全局生效，因此很容易造成多个组件之间的样式冲突问题1、全局样式：默认组件中的样式会作用到全局2、局部样式：可以给组件加上scoped属性，可以让样式
  • Go 学习笔记整合 进击的程序猿~ GO容器技术数据库golang学习docker1024程序员节
    包括go语言基础、Linux基础、docker、kubernetes、中间件、NoSQL等等。go语言基础：Golang基本数据结构：https://blog.csdn.net/qq_41822345/article/details/125350205Golang高级数据结构：https://blog.csdn.net/qq_41822345/article/details/125475150Go
  • scikit-image（Scikit-image 是用于图像处理的 Python 包，使用原生的 NumPy 数组作为图像对象） Clark-dj 图像处理pythonnumpy
    Scikitimage中文开发手册-开发者手册-腾讯云开发者社区-腾讯云昨天搜索一个函数时无意间发现这个网站，今天来学习一下，仅作学习笔记。measureskimage.measure.approximate_polygon（coords，...）近似具有指定公差的多边形链。skimage.measure.block_reduce（image，block_size）通过对局部块应用函数来下采样图像
  • 【CSDN】java使用POI&EasyExcel操作文件学习笔记 骑鱼过海的猫123 java学习笔记
    文章目录1.Apachepoi参考CSDNurl:[CSDNPOI文档](https://blog.csdn.net/fgghhfg574/article/details/103343030)参考B站视频:[B站POI视频](https://www.bilibili.com/video/BV1cG411M7ut?p=6&vd_source=31d376c1e57cf8a26a31cd3b47080
  • 嵌入式开发之STM32学习笔记day06 小程同学>o< 嵌入式学习之STM32stm32学习笔记
    基于STM32F103C8T6的开发实践——从入门到精通011.引言STM32系列微控制器是STMicroelectronics推出的一款高性能、低功耗的32位微控制器，广泛应用于嵌入式系统中。STM32F103C8T6是其中非常受欢迎的一款，凭借其强大的性能、丰富的外设接口和低廉的价格，成为了开发者的首选之一。本文将通过实例，详细介绍如何基于STM32F103C8T6进行开发，并带领读者完成从简
  • 简单工厂模式、工厂方法模式、抽象工厂模式 对比学习笔记 idgoodbye 简单工厂模式工厂方法模式抽象工厂模式
    工厂模式架构设计原则开闭原则：是指一个软件实体（如类、模块和函数）应该对扩展开放，对修改关闭。依赖倒置原则：是指设计代码结构时，高层模块不应该依赖低层模块，二者都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。单一职责：是指一个类只负责一个主要任务，避免因一个类负责两个以上任务时，修改其中一个任务代码导致另一个任务代码受到连带影响。接口隔离原则：是指用多个专门的接口，而不使用单一的总接口，客
  • 遗传算法与深度学习实战（2）——生命模拟及其应用 盼小辉丶 遗传算法与深度学习实战深度学习人工智能遗传算法
    遗传算法与深度学习实战（2）——生命模拟及其应用0.前言1.康威生命游戏1.1康威生命游戏的规则1.2实现康威生命游戏1.3空间生命和智能体模拟2.实现生命模拟3.生命模拟应用小结系列链接0.前言生命模拟是进化计算的一个特定子集，模拟了自然界中所观察到的自然过程，例如粒子或鸟群的聚集方式。生命模拟只是用来探索和优化问题的模拟形式之一，还有很多其他形式的模拟，可以更好地建模各种过程，但它们都源于康威
  • Spring-Boot学习笔记 戴帽子的小熊猫 学习笔记学习笔记springboot
    这个笔记是在自己学习的过程中根据实际用到的和学到的整理出来的，可能会有缺失，错误等，主要是给激励自己学习，遇到写不下去的情况给自己一个参考，请各位大佬发现问题提出问题时能嘴下留情，也希望多提建议，谢谢。本笔记长期更新（更新日期2024年9月21日）目录第1章.固定格式参考1.1application.yml1.2mapper.xml(详细操作见另一个文件[XML数据库操作笔记]())1.3appl
  • Linux命令学习笔记之 network NetworkManager kfepiza OS操作系统WindowsLinux等#LinuxCentOSUbuntu等linux学习centos
    networkNetworkManager前言CentOS7最小安装下的测试220511心得:启动network能打开网络,关闭network能关闭网络启动NetworkManager能打开网络,关闭不会关闭网络在两者都启动的情况下,单停network会断网,单停NetworkManager不会一些摘抄前言这两个东西在centOS7最小安装无勾选附加时就存在Ubuntu20.04中只有Networ
  • AI技术学习笔记系列001：FastLanguageModel.get_peft_model 函数各参数的详细解释 新说一二 人工智能学习笔记
    以下是关于代码中FastLanguageModel.get_peft_model函数各参数的详细解释，以及企业实际微调时的选择考量：参数详解及对微调的影响1.r=32（秩）作用：控制LoRA适配器的低秩矩阵的维度（秩），直接影响可训练参数数量。影响：r越大：适配器表达能力更强，能捕捉更复杂的任务特征，但可能导致过拟合（尤其数据量少时），训练时间和显存占用增加。r越小：参数量少，训练更快，显存占用低
  • Python个人学习笔记（2）：编程入门知识与基础语法介绍 NEET_LH 樵夫老师Python零基础课程个人学习笔记python学习笔记
    一、注释（一）作用1.对代码进行解释和说明避免自己忘了写的代码是做什么的——写给人看的，机器不运行不要去注释你代码做了什么，而要去注释我的代码为什么要这么做。用于记录思路、实现方法、代码功能注释很重要，大厂很重视，尤其日企2.调试代码报错的一篇代码，从下到上一句一句加#，依次运行，如果某行代码加了#后，程序运行成功，那么就是这行有问题，但这个方法不好。（二）注释方法1.单行注释==句子前加#快捷键
  • Java学习笔记1.1_初识 Java 火车爱上轨道 Java编程语言基础java学习
    初识Java前言一、Java概述1.什么是程序2.Java语言的产生和发展史3.Java可以做什么4.Java语言的特点二、Java语言环境搭建1.JDK、JRE、JVM关系2.安装JDK3.配置环境变量4.环境测试三、开发第一个Java程序1.开发Java程序的步骤2.用记事本开发Java程序四、Java程序的注释1.单行注释和多行注释2.文档注释五、Java程序的结构六、JavaAPI文档前言
  • IMX6ULL学习整理篇——UBoot的一些基础知识（1.编译流程） charlie114514191 从0开始的学习ARMv7aIMX6ULL芯片学习UBoot嵌入式软件编译
    前言笔者整理了最近刷IMX6ULL的一些学习笔记，这里打算稍微整理一下东西发上来作为作为一个补充正文大部分而言，当我们拿到源码的时候，一般都是——先使用make来生成一份针对我们目标开发板的配置。举个例子，正点原子针对他们的开发板（EMMC作为类似于我们电脑的硬盘，DDR类似我们电脑的内存），使用的就是他们自己配置的mx6ull_14x14_ddr512_emmc_defconfig文件。也就是说
  • STL学习笔记 2301_76962440 c++学习笔记
    包含数据结构和数学函数#includeusingnamespacestd;boolcmp(paira,pairb){//第二位从小到大if(a.second!=b.second)returna.secondb.first;}intgcd(inta,intb){if(!b)returna;elsereturngcd(b,a%b);}intlcm(inta,intb){returna/gcd(a,b)
  • MATAB学习笔记2 好大一口果汁 MATLAB学习笔记算法
    1.多项式拟合>>p=polyfit(DateNum,Pclose,1);%多项式拟合>>value=p(1)%将斜率赋值给value，作为股票的价值value=0.1212代码分析：%后面的内容是注释，ployfit（）有三个参数，第三个参数表示多项式的阶数，也就是最高次数。比如：第三个参数为1，说明为1次项，即一次函数，第三个参数为你要拟合的阶数，一阶直线拟合，二阶抛物线拟合，并非阶次越高越好
  • 网络运维学习笔记（DeepSeek优化版） 018 HCIA-Datacom综合实验03 技术小齐 网络运维学习
    文章目录综合实验3实验需求一：A公司网络规划二：B公司网络规划配置一、ip、vlan、vlanif，stp、eth-trunkSW1SW2R1二、ospfSW1R1三、NATR1ISP四、拒绝ping允许httpSW1五、右半部分vlan、dhcp、ospf、NATSW4R2综合实验3实验需求一：A公司网络规划SW1/2/3组成了A公司的交换网络，其中SW1是核心层，SW2/3是接入层。三台交换机
  • [学习笔记] Windows编程——GDI——（六）设备上下文 根本没在怕哦 Windows编程学习笔记windows
    前言：学习笔记，随时更新。如有谬误，欢迎指正。说明：红色字体为较为重要部分。绿色字体为个人理解部分。原文链接：https://learn.microsoft.com/en-us/windows/win32/gdi/device-contexts6设备上下文设备上下文是一种结构，用于定义一组图形对象及其关联属性，以及影响输出的图形模式。图形对象包括用于线条绘制的笔、用于绘制和填充的画刷、用于复制或滚
  • [学习笔记] Windows编程——GDI——（三）裁剪 根本没在怕哦 Windows编程学习笔记windows
    前言：学习笔记，随时更新。如有谬误，欢迎指正。说明：红色字体为较为重要部分。绿色字体为个人理解部分。原文链接：https://learn.microsoft.com/en-us/windows/win32/gdi/clipping3裁剪剪裁是将输出限制为应用程序窗口的工作区中的某个区域或路径的过程。3.1关于裁剪应用程序通过多种方式使用剪裁。Word和Excel应用程序剪裁键盘输入，使其不显示在页
  • Python 进程和线程-进程 vs. 线程 赔罪 Python系统学习python开发语言
    目录ThreadLocal小结进程vs.线程线程切换计算密集型vs.IO密集型异步IOThreadLocal在多线程环境下，每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好，因为局部变量只有线程自己能看见，不会影响其他线程，而全局变量的修改必须加锁。但是局部变量也有问题，就是在函数调用的时候，传递起来很麻烦：defprocess_student(name):std=Student
  • kaggle-ISIC 2024 - 使用 3D-TBP 检测皮肤癌-学习笔记 supernova121 学习笔记
    问题描述：通过从3D全身照片(TBP)中裁剪出单个病变来识别经组织学确诊的皮肤癌病例数据集描述：图像+临床文本信息评价指标：pAUC，用于保证敏感性高于指定阈值下的AUC主流方法分析（文本）基于CatBoost、LGBM和XGBoost三者的组合，为每个算法创建了XX个变体，总共XX个模型，进行集成学习。CatBoost在传统梯度提升决策树（GBDT）基础上，引入了一系列关键技术创新，以提升处理类
  • 数学 ：矩阵 极客 - L U 数学矩阵线性代数
    文章目录前言1.基本矩阵运算1.1矩阵加法1.2矩阵减法1.3矩阵乘法2.转置矩阵3.旋转矩阵小结【全文大纲】:https://blog.csdn.net/Engineer_LU/article/details/135149485前言在许多应用场合下，我们都需要用矩阵来表示公式，接下来简洁描述矩阵用法1.基本矩阵运算1.1矩阵加法∣a1b1c1d1∣+∣a2b2c2d2∣=∣a1+a2b1+b2c
  • Autoleaders控制组——51单片机学习笔记（2） Autoleaders控制组 邓翔 51单片机学习笔记
    51单片机学习（2）1.模块化编程1.1模块化编程的意义在学习单片机的途中，随着我们的知识不断扩展，我们能写出的代码也越来越复杂，越来越长了，有时我们自己写出的很长的代码，出现了错误，需要调试，但奈何自己的代码实在是太长了，真的不好分析到底是哪里出错了。这是因为我们将太多的函数和代码放在一个main.c的文件里，导致代码过度堆积。如果我们能够条理清晰地去将不同作用的代码和函数放在不同的xxx.c文
  • AI开发 - 算法基础 递归 的概念和入门（三）递归的进阶学习 minstbe PythonAI应用与观察算法学习深度优先
    前面我们通过2篇文章，一起了解了递归，以及使用递归来解决汉诺塔问题。今天我们在这个基础上，进一步地熟悉和学习递归。这篇学习笔记将涵盖递归的基本概念、应用、优化技巧、陷阱及与迭代的对比，并通过具体的Python代码示例和大家一起来深入理解递归的使用。一、巩固基础1.递归的概念递归，简单来说就是函数自己调用自己。听起来有点绕，但其实就像俄罗斯套娃，一层套一层，直到遇到最小的那个娃娃（基线条件）才停止。
  • 【STM32】USART串口收发HEX数据包&收发文本数据包 傍晚冰川 stm32网络嵌入式硬件单片机笔记学习c语言
    有关串口知识参考：【STM32】USART串口协议&串口外设-学习笔记-CSDN博客HEX模式/十六进制模式/二进制模式：以原始数据的形式显示文本模式/字符模式：以原始数据编码后的形式显示参考上面文章查看ASCII编码表HEX数据包包头包尾和载荷数据重复问题的解决方法：解决思路方法文本数据包文本模式有大量的字符可以作为包头包尾，可以有效避免载荷数据和包头包尾重复的问题HEX数据包和文本数据包两者的
  • 深入理解C++内存管理机制 qzw1210 C++c++学习笔记
    侯捷C++系列课程学习笔记：深入理解C++内存管理机制在侯捷老师的C++系列课程中，内存管理是一个极其重要且深刻的主题。通过对这部分内容的学习，我对C++的内存管理机制有了更深入的理解，特别是关于new/delete操作符、内存池设计以及智能指针的应用。一、C++内存分配的层次结构侯捷老师在课程中清晰地阐述了C++内存分配的层次结构，这让我对整个内存管理体系有了全局的认识：最底层：操作系统提供的内
  • Hadoop(一) 朱辉辉33 hadooplinux
    今天在诺基亚第一天开始培训大数据，因为之前没接触过Linux，所以这次一起学了，任务量还是蛮大的。 首先下载安装了Xshell软件，然后公司给了账号密码连接上了河南郑州那边的服务器，接下来开始按照给的资料学习，全英文的，头也不讲解，说锻炼我们的学习能力，然后就开始跌跌撞撞的自学。这里写部分已经运行成功的代码吧.    在hdfs下，运行hadoop fs -mkdir /u
  • maven An error occurred while filtering resources blackproof maven报错
    转：http://stackoverflow.com/questions/18145774/eclipse-an-error-occurred-while-filtering-resources   maven报错： maven An error occurred while filtering resources   Maven -> Update Proje
  • jdk常用故障排查命令 daysinsun jvm
    linux下常见定位命令： 1、jps      输出Java进程       -q       只输出进程ID的名称，省略主类的名称；       -m      输出进程启动时传递给main函数的参数；     &nb
  • java 位移运算与乘法运算 周凡杨 java位移运算乘法
      对于 JAVA 编程中，适当的采用位移运算，会减少代码的运行时间，提高项目的运行效率。这个可以从一道面试题说起：     问题： 用最有效率的方法算出2 乘以8 等於几?” 答案：2 << 3 由此就引发了我的思考，为什么位移运算会比乘法运算更快呢？其实简单的想想，计算机的内存是用由 0 和 1 组成的二
  • java中的枚举(enmu) g21121 java
    从jdk1.5开始，java增加了enum(枚举)这个类型，但是大家在平时运用中还是比较少用到枚举的，而且很多人和我一样对枚举一知半解，下面就跟大家一起学习下enmu枚举。先看一个最简单的枚举类型，一个返回类型的枚举： public enum ResultType { /** * 成功 */ SUCCESS, /** * 失败 */ FAIL,
  • MQ初级学习 510888780 activemq
    1.下载ActiveMQ 去官方网站下载：http://activemq.apache.org/ 2.运行ActiveMQ 解压缩apache-activemq-5.9.0-bin.zip到C盘，然后双击apache-activemq-5.9.0-\bin\activemq-admin.bat运行ActiveMQ程序。 启动ActiveMQ以后，登陆：http://localhos
  • Spring_Transactional_Propagation 布衣凌宇 springtransactional
    //事务传播属性 @Transactional(propagation=Propagation.REQUIRED)//如果有事务，那么加入事务，没有的话新创建一个 @Transactional(propagation=Propagation.NOT_SUPPORTED)//这个方法不开启事务 @Transactional(propagation=Propagation.REQUIREDS_N
  • 我的spring学习笔记12-idref与ref的区别 aijuans spring
    idref用来将容器内其他bean的id传给<constructor-arg>/<property>元素，同时提供错误验证功能。例如： <bean id ="theTargetBean" class="..." /> <bean id ="theClientBean" class=&quo
  • Jqplot之折线图 antlove jsjqueryWebtimeseriesjqplot
    timeseriesChart.html <script type="text/javascript" src="jslib/jquery.min.js"></script> <script type="text/javascript" src="jslib/excanvas.min.js&
  • JDBC中事务处理应用 百合不是茶 javaJDBC编程事务控制语句
      解释事务的概念; 事务控制是sql语句中的核心之一;事务控制的作用就是保证数据的正常执行与异常之后可以恢复   事务常用命令:             Commit提交         
  • [转]ConcurrentHashMap Collections.synchronizedMap和Hashtable讨论 bijian1013 java多线程线程安全HashMap
    在Java类库中出现的第一个关联的集合类是Hashtable，它是JDK1.0的一部分。 Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的――Hashtable的所有方法都是同步的。此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者HashMap是作为JDK1.2中的集合框架的一部分出现的，它通过提供一个不同步的
  • ng-if与ng-show、ng-hide指令的区别和注意事项 bijian1013 JavaScriptAngularJS
            angularJS中的ng-show、ng-hide、ng-if指令都可以用来控制dom元素的显示或隐藏。ng-show和ng-hide根据所给表达式的值来显示或隐藏HTML元素。当赋值给ng-show指令的值为false时元素会被隐藏，值为true时元素会显示。ng-hide功能类似，使用方式相反。元素的显示或
  • 【持久化框架MyBatis3七】MyBatis3定义typeHandler bit1129 TypeHandler
    什么是typeHandler? typeHandler用于将某个类型的数据映射到表的某一列上，以完成MyBatis列跟某个属性的映射   内置typeHandler MyBatis内置了很多typeHandler，这写typeHandler通过org.apache.ibatis.type.TypeHandlerRegistry进行注册，比如对于日期型数据的typeHandler，
  • 上传下载文件rz,sz命令 bitcarter linux命令rz
    刚开始使用rz上传和sz下载命令： 因为我们是通过secureCRT终端工具进行使用的所以会有上传下载这样的需求： 我遇到的问题： sz下载A文件10M左右，没有问题 但是将这个文件A再传到另一天服务器上时就出现传不上去，甚至出现乱码，死掉现象，具体问题 解决方法： 上传命令改为;rz -ybe 下载命令改为：sz -be filename 如果还是有问题： 那就是文
  • 通过ngx-lua来统计nginx上的虚拟主机性能数据 ronin47 ngx-lua　统计 解禁ip
    介绍 以前我们为nginx做统计,都是通过对日志的分析来完成.比较麻烦,现在基于ngx_lua插件,开发了实时统计站点状态的脚本,解放生产力.项目主页: https://github.com/skyeydemon/ngx-lua-stats 功能 支持分不同虚拟主机统计, 同一个虚拟主机下可以分不同的location统计. 可以统计与query-times request-time
  • java-68-把数组排成最小的数。一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的。例如输入数组{32, 321}，则输出32132 bylijinnan java
    import java.util.Arrays; import java.util.Comparator; public class MinNumFromIntArray { /** * Q68输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。 * 例如输入数组{32, 321}，则输出这两个能排成的最小数字32132。请给出解决问题
  • Oracle基本操作 ccii Oracle SQL总结Oracle SQL语法Oracle基本操作Oracle SQL
    一、表操作 1. 常用数据类型 NUMBER(p,s)：可变长度的数字。p表示整数加小数的最大位数，s为最大小数位数。支持最大精度为38位 NVARCHAR2(size)：变长字符串，最大长度为4000字节（以字符数为单位） VARCHAR2(size)：变长字符串，最大长度为4000字节（以字节数为单位） CHAR(size)：定长字符串，最大长度为2000字节，最小为1字节，默认
  • [强人工智能]实现强人工智能的路线图 comsci 人工智能
        1：创建一个用于记录拓扑网络连接的矩阵数据表      2:自动构造或者人工复制一个包含10万个连接(1000*1000)的流程图      3：将这个流程图导入到矩阵数据表中      4：在矩阵的每个有意义的节点中嵌入一段简单的
  • 给Tomcat，Apache配置gzip压缩(HTTP压缩)功能 cwqcwqmax9 apache
    背景： HTTP 压缩可以大大提高浏览网站的速度，它的原理是，在客户端请求网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏览。相对于普通的浏览过程HTML ,CSS,Javascript , Text ，它可以节省40%左右的流量。更为重要的是，它可以对动态生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等输出的网页也能进行压缩，
  • SpringMVC and Struts2 dashuaifu struts2springMVC
    SpringMVC VS Struts2 1: spring3开发效率高于struts 2: spring3 mvc可以认为已经100%零配置 3: struts2是类级别的拦截， 一个类对应一个request上下文， springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应 所以说从架构本身上 spring3 mvc就容易实现r
  • windows常用命令行命令 dcj3sjt126com windowscmdcommand
    在windows系统中，点击开始－运行，可以直接输入命令行，快速打开一些原本需要多次点击图标才能打开的界面，如常用的输入cmd打开dos命令行，输入taskmgr打开任务管理器。此处列出了网上搜集到的一些常用命令。winver 检查windows版本 wmimgmt.msc 打开windows管理体系结构(wmi) wupdmgr windows更新程序 wscrip
  • 再看知名应用背后的第三方开源项目 dcj3sjt126com ios
    知名应用程序的设计和技术一直都是开发者需要学习的，同样这些应用所使用的开源框架也是不可忽视的一部分。此前《 iOS第三方开源库的吐槽和备忘》中作者ibireme列举了国内多款知名应用所使用的开源框架，并对其中一些框架进行了分析，同样国外开发者 @iOSCowboy也在博客中给我们列出了国外多款知名应用使用的开源框架。另外txx's blog中详细介绍了 Facebook Paper使用的第三
  • Objective-c单例模式的正确写法 jsntghf 单例iosiPhone
    一般情况下，可能我们写的单例模式是这样的： #import <Foundation/Foundation.h> @interface Downloader : NSObject + (instancetype)sharedDownloader; @end #import "Downloader.h" @implementation
  • jquery easyui datagrid 加载成功，选中某一行 hae jqueryeasyuidatagrid数据加载
    1.首先你需要设置datagrid的onLoadSuccess $( '#dg' ).datagrid({onLoadSuccess :  function (data){      $( '#dg' ).datagrid( 'selectRow' ,3); }});   2.onL
  • jQuery用户数字打分评价效果 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/5.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery用户数字打分评分代码 - HoverTree</
  • mybatis的paramType kerryg DAOsql
    MyBatis传多个参数： 1、采用#{0},#{1}获得参数：    Dao层函数方法：     public User selectUser(String name,String area); 对应的Mapper.xml    <select id="selectUser" result
  • centos 7安装mysql5.5 MrLee23 centos
    首先centos7 已经不支持mysql，因为收费了你懂得，所以内部集成了mariadb，而安装mysql的话会和mariadb的文件冲突，所以需要先卸载掉mariadb，以下为卸载mariadb，安装mysql的步骤。   #列出所有被安装的rpm package rpm -qa | grep mariadb   #卸载 rpm -e mariadb-libs-5.
  • 利用thrift来实现消息群发 qifeifei thrift
               Thrift项目一般用来做内部项目接偶用的，还有能跨不同语言的功能，非常方便，一般前端系统和后台server线上都是3个节点，然后前端通过获取client来访问后台server，那么如果是多太server，就是有一个负载均衡的方法，然后最后访问其中一个节点。那么换个思路，能不能发送给所有节点的server呢，如果能就
  • 实现一个sizeof获取Java对象大小 teasp javaHotSpot内存对象大小sizeof
       由于Java的设计者不想让程序员管理和了解内存的使用，我们想要知道一个对象在内存中的大小变得比较困难了。本文提供了可以获取对象的大小的方法，但是由于各个虚拟机在内存使用上可能存在不同，因此该方法不能在各虚拟机上都适用，而是仅在hotspot 32位虚拟机上，或者其它内存管理方式与hotspot 32位虚拟机相同的虚拟机上 适用。     
  • SVN错误及处理 xiangqian0505 SVN提交文件时服务器强行关闭
    在SVN服务控制台打开资源库“SVN无法读取current” ---摘自网络 写道 SVN无法读取current修复方法 Can't read file : End of file found 文件：repository/db/txn_current、repository/db/current   其中current记录当前最新版本号，txn_current记录版本库中版本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他