1. 课堂准备

1.1 SpringBoot项目创建

1.1.1 阿里镜像地址

URL: https://start.aliyun.com

1.1.2 选择Springboot版本

说明: 其中选择web包 表示添加spring/springmvc等jar包文件

1.1.3 项目调试

运行程序,检查项目是否正常

如果启动没有问题 则如图所示:

2. Spring

2.1 Spring介绍

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。
Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。

2.2 传统项目开发的弊端

2.2.1 编辑Dog类

public class Dog {public void hello(){System.out.println("你好,我是小狗汪汪汪");}
}

2.2.2 编辑Cat类

public class Cat {public void hello(){System.out.println("你好,我是小猫喵喵喵");}
}

2.2.3 编辑测试类

package com.jt.demo1;public class User {//说明: 当前类中 Dog对象与User对象绑定.耦合性高//如果需要切换Cat对象.则需要手动修改代码.//所以得出结论,如果自己实例化对象,则不能实现很好的解耦.private static Dog dog = new Dog();//private static Cat cat = new Cat();public static void main(String[] args) {dog.hello();}
}

2.2.4 测试问题总结:

1. 如果类中的属性通过new 的方式直接绑定. 则类与属性的耦合性高.
2. 如果需要修改属性类型, 则需要修改代码. 后期扩展不方便.

2.3 面向接口开发

2.3.1 业务说明

由于Dog和Cat都属性Pet宠物, 并且都有hello方法. 则能否将该方法抽取到接口中. 实现代码的解耦呢?

2.3.2 封装Pet接口

package com.jt.demo2;public interface Pet {void hello();   //定义共同的hello接口方法
}

2.3.3 编辑2个实现类

1. 编辑Dog类

public class Dog implements Pet{public void hello(){System.out.println("你好,我是小狗汪汪汪");}
}

1. 编辑Cat类

public class Cat implements Pet{public void hello(){System.out.println("你好,我是小猫喵喵喵");}
}

2.3.4 编辑User测试类

package com.jt.demo2;public class User {//通过定义接口对象.以后用户直接使用属性,后续操作无需修改属性名//接口中赋值的实现类可以灵活的变化. 所以在一定程度上 降低了耦合性private static Pet pet = new Cat();public static void main(String[] args) {pet.hello();}
}

2.3.5 面向接口开发小结

1. 使用接口开发,可以在一定程度上 降低类与对象的耦合性. 提高开发效率. 如图所示

修改前:

修改后:

1. 暴露的问题说明:
   使用面向接口开发,虽然能在一定程度上降低代码的耦合性. 但是属性与类绑定的事实,并没有解决.
   如何解决该问题呢?
   

2.4 Spring-IOC(Inversion of Control)

2.4.1 IOC介绍

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期.

2.4.2 编辑User类

package com.jt.demo1;public class User {public void sayHello(){System.out.println("我是用户,需要被spring容器管理");}
}

2.4.3 编辑spring配置文件

在resource的目录下创建spring.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--知识点讲解:1.bean 被spring容器管理的对象称之为bean2.id    全局唯一变量一般类型首字母小写3.class class的路径信息,需要写全名--><bean id="user" class="com.jt.demo1.User"></bean>
</beans>

2.4.4 编辑test测试类

package com.jt;import com.jt.demo1.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestSpring {//spring入门案例@Testpublic void testDemo1(){//1.指定spring配置文件名称String resource = "spring.xml";//2.启动spring容器,需求xml配置文件信息. 实例化对象 交给容器管理ApplicationContext applicationContext = new ClassPathXmlApplicationContext(resource);//3.从容器中按照类型获取对象User user = applicationContext.getBean(User.class);//4.对象调用方法user.sayHello();}
}

2.5 关于Spring容器说明

解释: Spring容器的数据结构是Map集合,Map<key,value>, key是bean中id值, value是通过反射机制实例化的对象.
数据结构: Map<key,value> Map<user,User对象>
Bean标签:

     <bean id="user" class="com.jt.demo1.User"></bean>

2.5.1 反射源码

     //利用反射源码,实现对象创建@Testpublic void user() throws ClassNotFoundException, InstantiationException, IllegalAccessException {User user = (User) Class.forName("com.jt.demo1.User").newInstance();user.sayHello();}

2.6 Spring注解开发

2.6.1 关于注解开发说明

如果是2010年,那么还需要对xml配置文件有所了解,但是引入springboot之后,基本不需要使用xml配置文件了,一般都使用注解开发.

2.6.2 创建项目-格式如下

2.6.3 编辑配置类

package com.jt.config;import com.jt.demo1.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration  //标识这是一个配置类
@ComponentScan("com.jt") //添加注解包扫描,使得注解有效必须添加
public class SpringConfig {//将User对象交给Spring容器管理//key:  id就是方法名  user//value: 就是返回值类型@Beanpublic User user(){return new User();}
}

2.6.4 编辑User类

public class User {public User(){System.out.println("我是构造方法");}public void sayHello(){System.out.println("User对象,通过注解被spring容器管理");}
}

2.6.5 编辑测试类

class TestSpring {@Testpublic void testDemo1(){//通过注解的方式启动Spring容器ApplicationContext applicationContext =new AnnotationConfigApplicationContext(SpringConfig.class);User user = applicationContext.getBean(User.class);user.sayHello();}
}

2.7 Spring工厂管理对象(方式二)

2.7.1 关于工厂模式说明

由于很多对象没有办法直接初始化. 所以可以通过工厂模式的方式实现对象创建, 这个可以看作是Spring管理对象方式的补充

2.7.2 创建新项目

2.7.3 编辑工厂类

知识点:
1. @Component 注解. 将对象交给Spring容器管理. 如果不指定则默认就是类名首字母小写.
2. @Component(“xxxxx”) 给对象指定key的名称
3. 实现接口: FactoryBean 实现该接口,方法自动调用.获取对象

编辑配置类:

package com.jt.factory;import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;import java.util.Calendar;
@Component            //默认名称:     calendarFactory
//@Component("calendar")  //指定bean名称  calendar
public class CalendarFactory implements FactoryBean<Calendar> {@Overridepublic Calendar getObject() throws Exception {System.out.println("工厂模式调用,实例化方法");return Calendar.getInstance();}@Overridepublic Class<?> getObjectType() {return Calendar.class;}
}

2.7.4 编辑测试类

class Springdemo4ApplicationTests {@Testvoid contextLoads() {ApplicationContext applicationContext =new AnnotationConfigApplicationContext(SpringConfig.class);//Calendar calendar = (Calendar) applicationContext.getBean("calendarFactory");Calendar calendar = (Calendar) applicationContext.getBean(Calendar.class);System.out.println(calendar.getTime());}
}

2.8 单例多例说明

2.8.1 关于单例/多例说明

单例模式:
Spring容器中管理对象,在内存中只有一份.
多例模式:
Spring容器中管理对象,在内存中有多份.

2.8.2 关于单例/多例测试

属性值:
@Scope(“singleton”) //默认值 单例模式
@Scope(“prototype”)//默认值 多例模式

package com.jt.config;import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;@Configuration
@ComponentScan("com.jt")
public class SpringConfig {@Bean//@Scope("singleton") //默认值 单例模式@Scope("prototype")   //默认值 多例模式public User user(){return new User();}
}

2.8.3 案例测试效果

package com.jt;import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class TestSpring {@Testpublic void testDemo1(){ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);User user1 = applicationContext.getBean(User.class);User user2 = applicationContext.getBean(User.class);//如果单例模式  结果为true    如果是多例模式  结果为falseSystem.out.println(user1==user2);}
}

2.9 懒加载机制

注解: @Lazy 添加表示改为懒加载

2.9.1 编辑配置类

@Configuration
@ComponentScan("com.jt")
public class SpringConfig {@Bean//@Scope("singleton") //默认值 单例模式//@Scope("prototype")   //默认值 多例模式@Lazy                 //默认条件下都是立即加载public User user(){return new User();}
}

2.9.2 测试策略

 /*** 测试懒加载和单例多例的配比关系* 单例模式:    lazy:  false   立即加载*             lazy:  true    懒加载* 多例模式:    lazy:  false   懒加载*             lazy:  true    懒加载*/@Testpublic void testDemo2(){ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);applicationContext.getBean(User.class);}

2.10 Spring对象生命周期

2.10.1 编辑Dog类

//将类交给Spring容器管理
@Component
public class Dog {//这是构造方法public Dog(){System.out.println("我是构造方法,实例化对象");}//初始化方法@PostConstructpublic void init(){System.out.println("我是初始化方法,为属性赋值");}public void hello(){System.out.println("调用业务执行方法");}//销毁方法@PreDestroypublic void desotry(){System.out.println("我是销毁方法,做对象销毁操作");}
}

2.10.2 编辑测试类

     //测试生命周期函数@Testpublic void testDemo3(){AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);Dog dog = applicationContext.getBean(Dog.class);dog.hello();applicationContext.close();}

3. 依赖注入（Dependency Injection，简称DI）

3.1 依赖注入说明

关键注解: @Autowired
注入方式:
1.默认情况下采用类型注入. 一般条件下一个接口一个实现类
2.也可以按照名称进行注入.

3.2 代码结构说明

3.3 编辑接口/实现类

3.3.1 编辑Pet接口

public interface Pet {void hello();
}

3.3.2 编辑Cat类

@Component
public class Cat implements Pet{@Overridepublic void hello() {System.out.println("我是小猫,喵喵喵");}
}

3.3.3 编辑Dog类

@Component  //将对象交给Spring容器管理
public class Dog implements Pet{@Overridepublic void hello() {System.out.println("小狗汪汪汪");}
}

3.3.4 编辑测试类

@Component
public class User {/*** 注入方式:*      1. 按照类型注入*      2. 按照名称注入*/@Autowired@Qualifier("cat")private Pet pet;public void say(){pet.hello();}
}

3.4 三层代码结构

3.4.1 创建项目

3.4.2 MVC代码结构

1. 控制层 Controller 实现前后端参数接收的. @Controller注解
2. 业务层 Service 实现后端业务操作的 @Service注解
3. 持久层 Dao 实现持久层业务操作 @Repository 后期不用

3.4.3 编辑Dao层

1. 编辑Dao接口

public interface UserDao {void insert();
}

1. 编辑实现类

@Repository
public class UserDaoImpl implements UserDao{@Overridepublic void insert() {System.out.println("完成用户入库操作");}
}

3.4.4 编辑Service层

1. 编辑service接口层

public interface UserService {void insert();
}

1. 编辑ServiceImpl

@Service
public class UserServiceImpl implements UserService{@Autowiredprivate UserDao userDao;@Overridepublic void insert() {userDao.insert();}
}

3.4.5 编辑Controller层

package com.jt.controller;import com.jt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;@Controller
public class UserController {@Autowiredprivate UserService userService;public void insert(){userService.insert();}}

3.4.6 业务结果说明

3.5 动态为属性赋值操作

3.5.1 @value注解说明

可以通过@value注解动态为属性赋值.

3.5.2 编辑配置文件

user.id1=100
user.name1=张三

3.5.3 实现属性注入操作

说明: 通过@PropertySource 注解动态加载配置文件, 并且指定字符集编码格式utf-8

@Repository
@PropertySource(value = "classpath:/user.properties",encoding = "utf-8")
public class UserDaoImpl implements UserDao{@Value("${user.id1}")      //@Value("100")private Integer id;@Value("${user.name1}")    //@Value("tomcat") user.name获取的是计算机名称private String name;@Overridepublic void insert() {System.out.println("完成用户入库操作"+id+":"+name);}
}

4. Spring中的AOP

4.1 AOP介绍

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

AOP主要作用: 在不修改原有代码的条件下 对方法进行扩展

4.2 数据库代码-铺垫

4.2.1 代码结构如下

4.2.2 编辑UserDao接口/实现类

1. 编辑UserDao接口

public interface UserDao {void addUser();
}

1. 编辑UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao{@Overridepublic void addUser() {System.out.println("完成用户新增操作");}
}

4.2.3 编辑UserService接口/实现类

1. 编辑UserService

public interface UserService {void addUser();
}

1. 编辑UserServiceImpl

@Service
public class UserServiceImpl implements UserService{@Autowiredprivate UserDao userDao;@Overridepublic void addUser() {System.out.println("数据库事务开始");userDao.addUser();System.out.println("数据库事务提交");}
}

4.2.4 编辑测试类

class Springdemo8ProxyApplicationTests {@Testvoid contextLoads() {ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);UserService userService = context.getBean(UserService.class);userService.addUser();}}

测试结果如下:

4.2.5 关于测试代码总结

如果将业务代码和事务代码都写到一起,则会造成代码的耦合性增加. 不方便程序的扩展.

4.3 动态代理机制-JDK

4.3.1 关于动态代理的说明

Java中提供了动态代理的机制,可以利用API在运行期动态生成一个和原对象 “看起来” 一模一样的对象(代理对象). 用户的扩展功能,在动态代理中完成.

4.3.2 JDK动态代理

要求:
1. 要求被代理者必须有(实现)接口.

编辑代理对象:

package com.jt.proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class JDKProxy {/***  提供获取动态代理的方法*  参数说明:*      1.ClassLoader loader,  类加载器*      2.Class<?>[] interfaces,  被代理者的接口*      3.InvocationHandler h*/public static Object getObject(Object target){//1.获取目标对象的类加载器ClassLoader classLoader = target.getClass().getClassLoader();//2.获取被代理者的接口Class[] interfaces = target.getClass().getInterfaces();//3.利用动态代理获取对象return Proxy.newProxyInstance(classLoader, interfaces,getInvoInvocationHandler(target));}//构建InvocationHandler的方法public static InvocationHandler getInvoInvocationHandler(Object target){return new InvocationHandler() {//当代理对象调用方法时,则会调用invoke的方法@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result = null;System.out.println("数据库事务开始");result = method.invoke(target,args); //执行目标方法返回值System.out.println("数据库事务结束");return result;}};}
}

4.3.3 编辑测试类

class Springdemo8ProxyApplicationTests {@Testvoid contextLoads() {ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);UserService userService = context.getBean(UserService.class);//使用代理对象 调用方法UserService proxy = (UserService) JDKProxy.getObject(userService);proxy.addUser();}}

4.4 动态代理机制-CGLIB

4.4.1 Cglib代理说明

特点:
1.代理对象是目标对象的子类.

4.4.2 编辑Service实现类

由于特殊原因,Service中不能注入Dao. 暂时不管Dog数据的实例化操作

package com.jt.service;import com.jt.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class UserServiceImpl implements UserService{@Autowiredprivate UserDao userDao;@Overridepublic void addUser() {//System.out.println("数据库事务开始");//userDao.addUser();System.out.println("完成用户入库操作");//System.out.println("数据库事务提交");}
}

4.4.3 编辑cglib代理对象

package com.jt.proxy;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class CglibProxy {public static Object getObject(Object target){//创建增强器对象Enhancer enhancer = new Enhancer();//设置父级enhancer.setSuperclass(target.getClass());enhancer.setCallback(getMethodInterceptor());return enhancer.create();}public static MethodInterceptor getMethodInterceptor(){return new MethodInterceptor() {@Overridepublic Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("数据库事务开始");//执行父类的方法Object proxy = methodProxy.invokeSuper(obj,objects);System.out.println("数据库事务提交");return proxy;}};}}

4.4.4 编辑测试类

 @Testvoid testCGB(){ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);UserService userService = context.getBean(UserService.class);//使用代理对象 调用方法UserService proxy = (UserService) CglibProxy.getObject(userService);proxy.addUser();}

4.5 关于动态代理模式总结

1. JDK或者CBLIB都是根据原对象创建出来的代理对象. 并且主要的功能在代理对象中进行扩展.所有起到了代码解耦的作用.

4.6 Spring AOP

4.6.1 AOP介绍

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

总结: Spring中的AOP 利用代理对象在不修改源代码的条件下,对方法进行扩展.

4.6.2 AOP中专业术语(难点)

1).连接点: 用户可以被扩展的方法
2).切入点: 用户实际扩展的方法
3).通知: 扩展方法的具体实现
4).切面: 将通知应用到切入点的过程

4.6.3 通知类型

1).before通知 目标方法执行前执行
2).afterRrturning 通知 目标方法执行之后执行
3).afterThrowing 通知 目标方法报错时执行
4).after通知 目标方法执行之后 最后执行
5).around通知 目标方法执行前后都要执行

4.6.4 切入点表达式

1). bean(bean的Id号) 按照bean匹配
2). within(包名.类名) 可以使用通配符
3). execution(返回值类型 包名.类名.方法名(参数列表))
4). @annotation(包名.注解名称)

4.6.5 引入AOPjar包文件

         <!--引入AOPjar包文件--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>

4.6.5 编辑AOP文件

package com.jt.aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;@Aspect //定义切面类
@Component  //将切面交给Spring容器管理
@Order(2)   //如果是多个切面, 可以实现排序 数字越小越靠前
public class SpringAOP {//定义切入点表达式//@Pointcut("bean(userServiceImpl)")                   //通过bean的ID匹配//@Pointcut("within(com.jt.service.UserServiceImpl)")  //通过类型匹配//@Pointcut("execution(* com.jt.service..*.*(..))")    //通过方法参数匹配@Pointcut("@annotation(com.jt.anno.MyAnnotation)")     //注解匹配public void pointcut(){}@Before(value = "pointcut()")public void before(){System.out.println("我是前置通知");}@AfterReturning(value = "pointcut()")public void afterReturning(){System.out.println("我是后置通知");}@AfterThrowing(value = "pointcut()",throwing = "exception")public void afterThrowing(Exception exception){exception.printStackTrace();System.out.println("我是异常通知");}@After(value = "pointcut()")public void after(){System.out.println("我是最终通知");}@Around("pointcut()")public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("环绕通知开始前");joinPoint.proceed();System.out.println("环绕通知开始后");}
}

4.6.6 编辑AOP2文件

package com.jt.aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;@Aspect //定义切面类
@Component  //将切面交给Spring容器管理
@Order(1)
public class SpringAOP2 {//定义切入点表达式//@Pointcut("bean(userServiceImpl)")                   //通过bean的ID匹配//@Pointcut("within(com.jt.service.UserServiceImpl)")  //通过类型匹配//@Pointcut("execution(* com.jt.service..*.*(..))")    //通过方法参数匹配@Pointcut("@annotation(com.jt.anno.MyAnnotation)")     //注解匹配public void pointcut(){}@Around("pointcut()")public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("环绕通知开始前2");joinPoint.proceed();System.out.println("环绕通知开始后2");}
}

4.6.7 执行效果说明

框架系列课程-Spring新版本相关推荐

1. 【SSM框架系列】Spring - JdbcTemplate声明式事务

   JdbcTemplate概述 以往使用jdbc时,每次都需要自己获取PreparedStatement,执行sql语句,关闭连接等操作.操作麻烦冗余,影响编码的效率. Spring把对数据库的操作在j ...

2. 【SSM框架系列】Spring 的 AOP（面向切面编程）

   什么是 AOP AOP 为 Aspect Oriented Programming 的缩写,意思为面向切面编程,是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. AOP 是 OOP ...

3. 【SSM框架系列】Spring IoC（控制反转） DI（依赖注入）注解开发

   Spring注解开发 Spring是轻代码重配置的框架,配置比较繁重,会影响开发效率.这个时候可以通过注解开发,注解代替xml配置文件可以简化配置,提高开发效率. Spring原始注解 注解分为原始注 ...

4. 【SSM框架系列】Spring IoC（控制反转） DI（依赖注入）

   Spring是什么 Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control:反转控制)和 AOP(Aspect Orie ...

5. 框架系列课程-SpringMVC课程

   文章目录 1. SpringMVC 1.1 SpringMVC介绍 1.2 SpringMVC 入门案例 1.2.1 添加jar包 1.2.2 编辑YML配置文件 1.2.3 编辑Controller ...

6. 新浪微博新兵训练营系列课程——平台RPC框架介绍

   新浪微博新兵训练营系列课程--平台RPC框架介绍 课程大纲 1.RPC简介 1.1 什么是RPC 1.2 RPC与其他远程调用方式比较 2.Motan RPC框架 2.1 RPC服务框架 2.2 Mo ...

7. Spring框架系列之AOP思想

   微信公众号:compassblog 欢迎关注.转发,互相学习,共同进步! 有任何问题,请后台留言联系! 1.AOP概述 (1).什么是 AOP AOP 为 Aspect Oriented Progra ...

8. 【直播回顾】云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第19讲）：Java Spring Cloud微服务架构模式与开发实战...

   主讲人:徐雷(云栖社区特邀Java专家) 徐雷,花名:徐雷frank:资深架构师,MongoDB中文社区联席主席,吉林大学计算机学士,上海交通大学硕士.从事了 10年+开发工作,专注于分布式架构,Ja ...

9. WebCast《实战ASP.NET AJAX系列课程(2)：使用客户端框架创建“纯粹”的Ajax应用程序》相关资源...

   本课程将从头开始使用ASP.NET AJAX客户端框架/组件创建一个"纯粹"的Ajax应用程序的全过程.适合于开发者学习Ajax所带来的这种崭新的开发方式,即将表示层完全放在客户端 ...

最新文章

1. Eclipse+Tomcat7.0+MySQL 连接池设置
2. L Machining Disc Rotors
3. oracle复习笔记
4. spring mvc学习（10）:eclipse的环境前maven配置
5. 苹果AirPower总是跳票的原因找到了？或因商标被抢注
6. 用C语言扩展lua模块（入门）
7. MySQL GROUP_CONCAT长度限制引发的一场灾难
8. 混合汇编 src-control
9. vue2学生签到管理系统案例
10. 免安装、免激活，绿色版的电脑软件下载网站
11. 一文搞明白DNS与域名解析
12. 对单位cps和单位kc的理解
13. eleme后台的el-form表单分为左右两边放数据 :inline=true
14. 向98年的华为学习：没有高管办公室的青铜器软件
15. 创业公司该如何设计激励员工的期权池
16. IE浏览器发送两次相同请求第二次读取第一次缓存问题
17. docker的目录挂载
18. Objective-C知识点总结
19. Spring实训 个人博客二 详情页
20. 登录成功后怎么跳转页面html,怎么设置登录成功后跳转到相应的页面

热门文章

1. App如何在background状态下存活
2. Wyn Enterprise 报表数据过滤
3. 删除计算机系学生(在student表中),数据库原理及应用（第2版）习题参考答案
4. 敏捷开发系列学习总结（8）——创业公司研发团队怎么建设
5. Vuetify——使用icon图标
6. 网页版简易计算器（仅加减乘除）
7. 一起talk C栗子吧（第一百九十三回：C语言实例--DIY less命令二 ）
8. 静夜思：“小微科技公司”如何建立自己的竞争优势
9. 计算机发展史资料简介,计算机发展史简介
10. mysql sql语句 编辑器_技巧：三个非常实用的开源SQL编辑器