精华内容
下载资源
问答
  • Spring框架介绍及使用

    万次阅读 多人点赞 2018-03-17 10:49:54
    Spring框架—控制反转(IOC) 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:(IoC) 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 ...4 依赖注入...

    Spring框架—控制反转(IOC)

    1 Spring框架概述

    1.1 什么是Spring

    Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

    1.2 Spring的优点
    • 方便解耦,简化开发 (高内聚低耦合)
      Spring就是一个大工厂(容器),可以将所有对象创建和依赖关系维护,交给Spring管理
      spring工厂是用于生成bean
    • AOP编程的支持
      Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
    • 声明式事务的支持
      只需要通过配置就可以完成对事务的管理,而无需手动编程
    • 方便程序的测试
      Spring对Junit4支持,可以通过注解方便的测试Spring程序
    • 方便集成各种优秀框架
      Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持
    • 降低JavaEE API的使用难度
      Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低
    1.3 Spring的体系结构

    这里写图片描述

    2 入门案例:(IoC)

    2.1导入jar包
    • 4 + 1 : 4个核心(beans、core、context、expression) + 1个依赖(commons-loggins…jar)
      这里写图片描述
      这里写图片描述
    2.2目标类
    • 提供UserService接口和实现类
    • 获得UserService实现类的实例
      之前开发中,直接new一个对象即可。学习spring之后,将由Spring创建对象实例–> IoC 控制反转(Inverse of Control)
      之后需要实例对象时,从spring工厂(容器)中获得,需要将实现类的全限定名称配置到xml文件中
    public interface UserService {
    	public void addUser();
    }
    public class UserServiceImpl implements UserService {
    	@Override
    	public void addUser() {
    		System.out.println("a_ico add user");
    	}
    }
    
    2.3 配置文件
    • 位置:任意,开发中一般在classpath下(src)
    • 名称:任意,开发中常用applicationContext.xml
    • 内容:添加schema约束
      约束文件位置:spring-framework-3.2.0.RELEASE\docs\spring-framework-reference\html\ xsd-config.html
    <?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">
    	<!-- 配置service 
    		<bean> 配置需要创建的对象
    			id :用于之后从spring容器获得实例时使用的
    			class :需要创建实例的全限定类名
    	-->
    	<bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl"></bean>
    </beans>
    
    2.4测试
       @Test
    	public void demo02(){
    		//从spring容器获得
    		//1 获得容器
    		String xmlPath = "com/itheima/a_ioc/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		//2获得内容 --不需要自己new,都是从spring容器获得
    		UserService userService = (UserService) applicationContext.getBean("userServiceId");
    		userService.addUser();	
    

    3 入门案例:DI

    • 例如:
      class BookServiceImpl{
          //之前开发:接口 = 实现类  (service和dao耦合)
      	//private BookDao bookDao = new BookDaoImpl();
      	//spring之后 (解耦:service实现类使用dao接口,不知道具体的实现类)
      	private BookDao bookDao;
      	setter方法
      

    }
    模拟spring执行过程
    创建service实例:BookService bookService = new BookServiceImpl() -->IoC
    创建dao实例:BookDao bookDao = new BookDaoImple() -->IoC
    将dao设置给service:bookService.setBookDao(bookDao); -->DI

    ##### 3.1 目标类
    - 创建BookService接口和实现类
    - 创建BookDao接口和实现类
    - 将dao和service配置 xml文件
    - 使用api测试
    ##### 3.2 dao
    ```java
    public interface BookDao {
      public void save();
    }
    public class BookDaoImpl implements BookDao {
    
      @Override
      public void save() {
      	System.out.println("di  add book");
      }
    }
    
    3.3 service
    public interface BookService {
    
    	public abstract void addBook();
    
    }
    public class BookServiceImpl implements BookService {
    	
    	// 方式1:之前,接口=实现类
    //	private BookDao bookDao = new BookDaoImpl();
    	// 方式2:接口 + setter
    	private BookDao bookDao;
    	public void setBookDao(BookDao bookDao) {
    		this.bookDao = bookDao;
    	}
    	
    	@Override
    	public void addBook(){
    		this.bookDao.save();
    	}
    
    }
    
    3.4 配置文件
    <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">
    	<!-- 
    	模拟spring执行过程
    		创建service实例:BookService bookService = new BookServiceImpl()	IoC  <bean>
    		创建dao实例:BookDao bookDao = new BookDaoImpl()			IoC
    		将dao设置给service:bookService.setBookDao(bookDao);		DI   <property>
    		
    		<property> 用于进行属性注入
    			name: bean的属性名,通过setter方法获得
    				setBookDao ##> BookDao  ##> bookDao
    			ref :另一个bean的id值的引用
    	 -->
    
    	<!-- 创建service -->
    	<bean id="bookServiceId" class="com.itheima.b_di.BookServiceImpl">
    		<property name="bookDao" ref="bookDaoId"></property>
    	</bean>
    	
    	<!-- 创建dao实例 -->
    	<bean id="bookDaoId" class="com.itheima.b_di.BookDaoImpl"></bean>
    	
    
    </beans>
    
    3.5 测试
    	@Test
    	public void demo01(){
    		//从spring容器获得
    		String xmlPath = "com/itheima/b_di/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		BookService bookService = (BookService) applicationContext.getBean("bookServiceId");	
    		bookService.addBook();
    	}
    

    4 依赖注入装配Bean 基于xml

    4.1属性依赖注入
    • 依赖注入方式:手动装配 和 自动装配
      • 手动装配:一般进行配置信息都采用手动
        基于xml装配:构造方法、setter方法
      • 基于注解装配:
    4.1.1 构造方法

    目标类

    public class User {
    	
    	private Integer uid;
    	private String username;
    	private Integer age;
    	
    	public User(Integer uid, String username) {
    		super();
    		this.uid = uid;
    		this.username = username;
    	}
    	
    	public User(String username, Integer age) {
    		super();
    		this.username = username;
    		this.age = age;
    	}
    	
    

    spring配置

    	<!-- 构造方法注入 
    		* <constructor-arg> 用于配置构造方法一个参数argument
    			name :参数的名称
    			value:设置普通数据
    			ref:引用数据,一般是另一个bean id值
    			
    			index :参数的索引号,从0开始 。如果只有索引,匹配到了多个构造方法时,默认使用第一个。
    			type :确定参数类型
    		例如:使用名称name
    			<constructor-arg name="username" value="jack"></constructor-arg>
    			<constructor-arg name="age" value="18"></constructor-arg>
    		例如2:【类型type 和  索引 index】
    			<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    			<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    	-->
    	<bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
    		<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    		<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    	</bean>
    
    4.1.2 setter方法
    <!-- setter方法注入 
    		* 普通数据 
    			<property name="" value="值">
    			等效
    			<property name="">
    				<value>* 引用数据
    			<property name="" ref="另一个bean">
    			等效
    			<property name="">
    				<ref bean="另一个bean"/>
    	
    	-->
    	<bean id="personId" class="com.itheima.f_xml.b_setter.Person">
    		<property name="pname" value="阳志"></property>
    		<property name="age">
    			<value>1234</value>
    		</property>
    		
    		<property name="homeAddr" ref="homeAddrId"></property>
    		<property name="companyAddr">
    			<ref bean="companyAddrId"/>
    		</property>
    	</bean>
    	
    	<bean id="homeAddrId" class="com.itheima.f_xml.b_setter.Address">
    		<property name="addr" value="阜南"></property>
    		<property name="tel" value="911"></property>
    	</bean>
    	<bean id="companyAddrId" class="com.itheima.f_xml.b_setter.Address">
    		<property name="addr" value="北京八宝山"></property>
    		<property name="tel" value="120"></property>
    	</bean>
    
    4.2 集合依赖注入
    <!-- 
    		集合的注入都是给<property>添加子标签
    			数组:<array>
    			List:<list>
    			Set:<set>
    			Map:<map> ,map存放k/v 键值对,使用<entry>描述
    			Properties:<props>  <prop key=""></prop>  【】
    			
    		普通数据:<value>
    		引用数据:<ref>
    	-->
    	<bean id="collDataId" class="com.itheima.f_xml.e_coll.CollData" >
    		<property name="arrayData">
    			<array>
    				<value>DS</value>
    				<value>DZD</value>
    				<value>屌丝</value>
    				<value>屌中屌</value>
    			</array>
    		</property>
    		
    		<property name="listData">
    			<list>
    				<value>于嵩楠</value>
    				<value>曾卫</value>
    				<value>杨煜</value>
    				<value>曾小贤</value>
    			</list>
    		</property>
    		
    		<property name="setData">
    			<set>
    				<value>停封</value>
    				<value>薄纸</value>
    				<value>关系</value>
    			</set>
    		</property>
    		
    		<property name="mapData">
    			<map>
    				<entry key="jack" value="杰克"></entry>
    				<entry>
    					<key><value>rose</value></key>
    					<value>肉丝</value>
    				</entry>
    			</map>
    		</property>
    		
    		<property name="propsData">
    			<props>
    				<prop key="高富帅"></prop>
    				<prop key="白富美"></prop>
    				<prop key="男屌丝"></prop>
    			</props>
    		</property>
    	</bean>
    

    5 依赖注入装配Bean 基于注解

    • 注解:就是一个类,使用@注解名称
    • 开发中:使用注解 取代 xml配置文件。
      1.@Component取代<bean class="">
      @Component("id") 取代 <bean id="" class="">
      2.web开发,提供3个@Component注解衍生注解(功能一样)取代
      @Repository :dao层
      @Service:service层
      @Controller:web层
      3.依赖注入,给私有字段设值,也可以给setter方法设值
      • 普通值:@Value(" ")
      • 引用值:
        方式1:按照【类型】注入 @Autowired 方式2:按照【名称】注入1 @Autowired @Qualifier("名称") 方式3:按照【名称】注入2 @Resource("名称")
        4.生命周期
        初始化:@PostConstruct 销毁:@PreDestroy
        5.作用域
        @Scope("prototype") 多例
        注解使用前提,添加命名空间,让spring扫描含有注解类
      
      <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans 
         					   http://www.springframework.org/schema/beans/spring-beans.xsd
         					   http://www.springframework.org/schema/context 
         					   http://www.springframework.org/schema/context/spring-context.xsd">
      <!-- 组件扫描,扫描含有注解的类 -->
      <context:component-scan base-package="com.itheima.g_annotation.a_ioc"></context:component-scan>
      
    ```
    

    Spring框架—面向切面编程(AOP)

    1 什么是AOP

    • 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP(面向对象编程)的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
    • AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码
    • 经典应用:事务管理、性能监视、安全检查、缓存 、日志等
    • Spring AOP使用纯Java实现,不需要专门的编译过程和类加载器,在运行期通过代理方式向目标类织入增强代码
    • AspectJ是一个基于Java语言的AOP框架,Spring2.0开始,Spring AOP引入对Aspect的支持,AspectJ扩展了Java语言,提供了一个专门的编译器,在编译时提供横向代码的织入

    2 AOP实现原理

    • aop底层将采用代理机制进行实现。
    • 接口 + 实现类 :spring采用 jdk 的动态代理Proxy。
    • 实现类:spring 采用 cglib字节码增强。

    3 AOP术语【掌握】

    1.target:目标类,需要被代理的类。例如:UserService
    2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如:所有的方法
    3.PointCut 切入点:已经被增强的连接点。例如:addUser()
    4.advice 通知/增强,增强代码。例如:after、before
    5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
    6.proxy 代理类
    7. Aspect(切面): 是切入点pointcut和通知advice的结合
    一个线是一个特殊的面。
    一个切入点和一个通知,组成成一个特殊的面。
    这里写图片描述

    4 AOP实现方式

    4.1手动方式

    4.1.1JDK动态代理
    • JDK动态代理 对“装饰者”设计模式 简化。使用前提:必须有接口

    1.目标类:接口 + 实现类

    public interface UserService {
    	public void addUser();
    	public void updateUser();
    	public void deleteUser();
    }
    

    2.切面类:用于存通知 MyAspect

    public class MyAspect {	
    	public void before(){
    		System.out.println("鸡首");
    	}	
    	public void after(){
    		System.out.println("牛后");
    	}
    }
    

    3.工厂类:编写工厂生成代理

    public class MyBeanFactory {
    	
    	public static UserService createService(){
    		//1 目标类
    		final UserService userService = new UserServiceImpl();
    		//2切面类
    		final MyAspect myAspect = new MyAspect();
    		/* 3 代理类:将目标类(切入点)和 切面类(通知) 结合 --> 切面
    		 * 	Proxy.newProxyInstance
    		 * 		参数1:loader ,类加载器,动态代理类 运行时创建,任何类都需要类加载器将其加载到内存。
    		 * 			一般情况:当前类.class.getClassLoader();
    		 * 					目标类实例.getClass().get...
    		 * 		参数2:Class[] interfaces 代理类需要实现的所有接口
    		 * 			方式1:目标类实例.getClass().getInterfaces()  ;注意:只能获得自己接口,不能获得父元素接口
    		 * 			方式2:new Class[]{UserService.class}   
    		 * 			例如:jdbc 驱动  --> DriverManager  获得接口 Connection
    		 * 		参数3:InvocationHandler  处理类,接口,必须进行实现类,一般采用匿名内部
    		 * 			提供 invoke 方法,代理类的每一个方法执行时,都将调用一次invoke
    		 * 				参数31:Object proxy :代理对象
    		 * 				参数32:Method method : 代理对象当前执行的方法的描述对象(反射)
    		 * 					执行方法名:method.getName()
    		 * 					执行方法:method.invoke(对象,实际参数)
    		 * 				参数33:Object[] args :方法实际参数
    		 * 
    		 */
    		UserService proxService = (UserService)Proxy.newProxyInstance(
    								MyBeanFactory.class.getClassLoader(), 
    								userService.getClass().getInterfaces(), 
    								new InvocationHandler() {
    									
    									@Override
    									public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    										
    										//前执行
    										myAspect.before();
    										
    										//执行目标类的方法
    										Object obj = method.invoke(userService, args);
    										
    										//后执行
    										myAspect.after();
    										
    										return obj;
    									}
    								});
    		
    		return proxService;
    	}
    
    }
    

    4.测试

    @Test
    	public void demo01(){
    		UserService userService = MyBeanFactory.createService();
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    
    4.1.2 CGLIB字节码增强
    • 没有接口,只有实现类。
    • 采用字节码增强框架 cglib,在运行时 创建目标类的子类,从而对目标类进行增强。

    工厂类

    public class MyBeanFactory {
    	
    	public static UserServiceImpl createService(){
    		//1 目标类
    		final UserServiceImpl userService = new UserServiceImpl();
    		//2切面类
    		final MyAspect myAspect = new MyAspect();
    		// 3.代理类 ,采用cglib,底层创建目标类的子类
    		//3.1 核心类
    		Enhancer enhancer = new Enhancer();
    		//3.2 确定父类
    		enhancer.setSuperclass(userService.getClass());
    		/* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
    		 * 	intercept() 等效 jdk  invoke()
    		 * 		参数1、参数2、参数3:以invoke一样
    		 * 		参数4:methodProxy 方法的代理
    		 * 		
    		 * 
    		 */
    		enhancer.setCallback(new MethodInterceptor(){
    
    			@Override
    			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    				
    				//前
    				myAspect.before();
    				
    				//执行目标类的方法
    				Object obj = method.invoke(userService, args);
    				// * 执行代理类的父类 ,执行目标类 (目标类和代理类 父子关系)
    				methodProxy.invokeSuper(proxy, args);
    				
    				//后
    				myAspect.after();
    				
    				return obj;
    			}
    		});
    		//3.4 创建代理
    		UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
    		
    		return proxService;
    	}
    
    }
    

    4.2半自动

    • 让spring 创建代理对象,从spring容器中手动的获取代理对象
    4.2.1目标类
    public interface UserService {
    	public void addUser();
    	public void updateUser();
    	public void deleteUser();
    }
    
    4.2.2切面类
    /**
     * 切面类中确定通知,需要实现不同接口,接口就是规范,从而就确定方法名称。
     * * 采用“环绕通知” MethodInterceptor
     *
     */
    public class MyAspect implements MethodInterceptor {
    
    	@Override
    	public Object invoke(MethodInvocation mi) throws Throwable {
    		
    		System.out.println("前3");
    		
    		//手动执行目标方法
    		Object obj = mi.proceed();
    		
    		System.out.println("后3");
    		return obj;
    	}
    }
    
    4.2.3Spring 配置
    <!-- 1 创建目标类 -->
    	<bean id="userServiceId" class="com.itheima.b_factory_bean.UserServiceImpl"></bean>
    	<!-- 2 创建切面类 -->
    	<bean id="myAspectId" class="com.itheima.b_factory_bean.MyAspect"></bean>
    
    	<!-- 3 创建代理类 
    		* 使用工厂bean FactoryBean ,底层调用 getObject() 返回特殊bean
    		* ProxyFactoryBean 用于创建代理工厂bean,生成特殊代理对象
    			interfaces : 确定接口们
    				通过<array>可以设置多个值
    				只有一个值时,value=""
    			target : 确定目标类
    			interceptorNames : 通知 切面类的名称,类型String[],如果设置一个值 value=""
    			optimize :强制使用cglib
    				<property name="optimize" value="true"></property>
    		底层机制
    			如果目标类有接口,采用jdk动态代理
    			如果没有接口,采用cglib 字节码增强
    			如果声明 optimize = true ,无论是否有接口,都采用cglib
    		
    	-->
    	<bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
    		<property name="interfaces" value="com.itheima.b_factory_bean.UserService"></property>
    		<property name="target" ref="userServiceId"></property>
    		<property name="interceptorNames" value="myAspectId"></property>
    	</bean>
    
    4.2.4 测试
    	@Test
    	public void demo01(){
    		String xmlPath = "com/itheima/b_factory_bean/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		
    		//获得代理类
    		UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    

    4.3全自动

    • 从spring容器获得目标类,如果配置aop,spring将自动生成代理。
    4.3.1 Spring配置
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans 
           					   http://www.springframework.org/schema/beans/spring-beans.xsd
           					   http://www.springframework.org/schema/aop 
           					   http://www.springframework.org/schema/aop/spring-aop.xsd">
    	<!-- 1 创建目标类 -->
    	<bean id="userServiceId" class="com.itheima.c_spring_aop.UserServiceImpl"></bean>
    	<!-- 2 创建切面类(通知) -->
    	<bean id="myAspectId" class="com.itheima.c_spring_aop.MyAspect"></bean>
    	<!-- 3 aop编程 
    		3.1 导入命名空间
    		3.2 使用 <aop:config>进行配置
    				proxy-target-class="true" 声明时使用cglib代理
    			<aop:pointcut> 切入点 ,从目标对象获得具体方法
    			<aop:advisor> 特殊的切面,只有一个通知 和 一个切入点
    				advice-ref 通知引用
    				pointcut-ref 切入点引用
    		3.3 切入点表达式
    			execution(* com.itheima.c_spring_aop.*.*(..))
    			选择方法         返回值任意   包             类名任意   方法名任意   参数任意
    		
    	-->
    	<aop:config proxy-target-class="true">
    		<aop:pointcut expression="execution(* com.itheima.c_spring_aop.*.*(..))" id="myPointCut"/>
    		<aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
    	</aop:config>
    </beans>
    
    4.3.2 测试
    	@Test
    	public void demo01(){
    		String xmlPath = "com/itheima/c_spring_aop/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		
    		//获得目标类
    		UserService userService = (UserService) applicationContext.getBean("userServiceId");
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    
    展开全文
  • ECharts介绍及使用方法

    万次阅读 多人点赞 2018-08-23 12:54:37
    首先简单介绍一下,ECharts是一个纯JavaScript图表库,底层依赖于轻量级的Canvas类库ZRender,基于BSD开原协议,是一款非常优秀的可视化前端框架。 官网地址:http://echarts.baidu.com/ 1.首先在官网选择合适的...

    前面做项目时用到ECharts,今天特此整理一下,作为笔记,同时希望帮助更多人。

    首先简单介绍一下,ECharts是一个纯JavaScript图表库,底层依赖于轻量级的Canvas类库ZRender,基于BSD开原协议,是一款非常优秀的可视化前端框架。

    官网地址:http://echarts.baidu.com/

    1.首先在官网 选择合适的下载版本

           http://echarts.baidu.com/download.html

    2.引入Echarts

     <script  src="js/echarts.js"></script>

    3.绘制一个简单的图表

          准备一个DOM容器 

     <div style="border:2px solid #666;width:49%;height:450px;float:left" id="chartmain"></div>

    4.创建一个简单的雷达图

    <script type="text/javascript">
    window.onload = function (){
    		//指定图表的配置项和数据
    		option = {
    				//标题	
    			    title: {
    			        text: '基础雷达图'
    			    },
    			    tooltip: {},
    			    legend: {
    			        data: ['预算分配(Allocated Budget)', '实际开销(Actual Spending)']
    			    },
    			    radar: {
    			        // shape: 'circle',
    			        name: {
    			            textStyle: {
    			                color: '#fff',
    			                backgroundColor: '#999',
    			                borderRadius: 3,
    			                padding: [3, 5]
    			           }
    			        },
    			        indicator: [
    			           { name: '销售(sales)', max: 6500},
    			           { name: '管理(Administration)', max: 16000},
    			           { name: '信息技术(Information Techology)', max: 30000},
    			           { name: '客服(Customer Support)', max: 38000},
    			           { name: '研发(Development)', max: 52000},
    			           { name: '市场(Marketing)', max: 25000}
    			        ]
    			    },
    			    series: [{
    			        name: '预算 vs 开销(Budget vs spending)',
    			        type: 'radar',
    			        // areaStyle: {normal: {}},
    			        data : [
    			            {
    			                value : [4300, 10000, 28000, 35000, 50000, 19000],
    			                name : '预算分配(Allocated Budget)'
    			            },
    			             {
    			                value : [5000, 14000, 28000, 31000, 42000, 21000],
    			                name : '实际开销(Actual Spending)'
    			            }
    			        ]
    			    }]
    			};
    			//获取dom容器
    			var myChart = echarts.init(document.getElementById('chartmain'));
    			// 使用刚指定的配置项和数据显示图表。
    			myChart.setOption(option);
    }
    </script>

    这样一个简单的雷达图就ok了,下面看下效果图

              

     5.动态的柱状图

       (1)还是创建一个装ECharts的DOM容器

       (2)后台返回数据

         (3)前台JavaScript代码

              

    <script type="text/javascript">
    
    
      window.onload = function (){
    	//财务看年度的合同金额echart数据源
    	$.ajax({
    		url:'',
    		type:'post',
    		datatype:'json',
    		success : function(data){
    			var partner = new Array();//公司名
    			for(var i=0;i<data.length;i++){
    				partner.push(data[i].partner);
    			} 
    			var odata=[];
    			for(var i=0;i<data.length;i++){
    				var obj={};
    				obj.name=partner[i];
    				obj.type='bar';
    				obj.data=[data[i].qyearOne,data[i].qyearTwo,data[i].qyearThree,data[i].qyearFour,data[i].yearOne,data[i].yearTwo,data[i].yearThree,data[i].yearFour,data[i].hyearOne,data[i].hyearTwo,data[i].hyearThree,data[i].hyearFour];
    				obj.barWidth=30;//宽度
    				odata.push(obj);
    			}
    			option = {
    			    tooltip : {
    			        trigger: 'axis'
    			    },
    			    legend: {
    			        data:partner
    			    },
    			    toolbox: {
    			        show : true,
    			    },
    			    calculable : true,
    			    xAxis : [{
    			            type : 'category',
    			            data :[qyear+'Q1',qyear+'Q2',qyear+'Q3',qyear+'Q4',year+'Q1',year+'Q2',year+'Q3',year+'Q4',hyear+'Q1',hyear+'Q2',hyear+'Q3',hyear+'Q4']
    			        }],
    			    yAxis : [{
    			            type : 'value'
    			        }],
    			     
    			    series : odata //前台组装数据
    			};
                          //获取要赋值的DOM控件
    			  var myChart = echarts.init(document.getElementById('chartmain'));
                          //赋值
    			  myChart.setOption(option);
    		} 
    	});
    </script>

    这样一个前后台交互的柱状图就ok了,效果图如下。

       

    以上就是本文的全部内容,希望对大家的学习有所帮助,欢迎评论交流。能get到知识点不要忘了关注点个赞~ 拒绝白嫖从我们做起hh~ 

    展开全文
  • Hadoop介绍

    万次阅读 2020-10-06 11:22:51
    Hadoop介绍Hadoop的介绍以及发展历史Hadoop的历史版本介绍Hadoop三大公司发型版本介绍Hadoop的模块组成 Hadoop的介绍以及发展历史 Hadoop之父Doug Cutting Hadoop最早起源于lucene下的Nutch。Nutch的设计目标是...

    Hadoop的介绍以及发展历史

    Hadoop之父Doug Cutting
    在这里插入图片描述

    1. Hadoop最早起源于lucene下的Nutch。Nutch的设计目标是构建一个大型的全网搜索引擎,包括网页抓取、索引、查询等功能,但随着抓取网页数量的增加,遇到了严重的可扩展性问题——如何解决数十亿网页的存储和索引问题。
    2. 2003年、2004年谷歌发表的三篇论文为该问题提供了可行的解决方案。
      ——分布式文件系统(GFS),可用于处理海量网页的存储
      ——分布式计算框架MAPREDUCE,可用于处理海量网页的索引计算问题。
      ——分布式的结构化数据存储系统Bigtable,用来处理海量结构化数据。
    3. Doug Cutting基于这三篇论文完成了相应的开源实现HDFS和MAPREDUCE,并从Nutch中剥离成为独立项目HADOOP,到2008年1月,HADOOP成为Apache顶级项目(同年,cloudera公司成立),迎来了它的快速发展期。
      为什么叫Hadoop? Logo为什么是黄色的大象?
      狭义上来说,Hadoop就是单独指代Hadoop这个软件(HDFS+MAPREDUCE)
      广义上来说,Hadoop指代大数据的一个生态圈(Hadoop生态圈),包括很多其他的软件。

    Hadoop的历史版本介绍

    0.x系列版本:Hadoop当中最早的一个开源版本,在此基础上演变而来的1.x以及2.x的版本
    1.x版本系列:Hadoop版本当中的第二代开源版本,主要修复0.x版本的一些bug等
    2.x版本系列:架构产生重大变化,引入了yarn平台等许多新特性
    在这里插入图片描述

    Hadoop三大公司发型版本介绍

    1、免费开源版本apache:http://Hadoop.apache.org/
    优点:拥有全世界的开源贡献者,代码更新迭代版本比较快,
    缺点:版本的升级,版本的维护,版本的兼容性,版本的补丁都可能考虑不太周到,学习可以用,实际生产工作环境尽量不要使用
    apache所有软件的下载地址(包括各种历史版本):
    http://archive.apache.org/dist/
    2、免费开源版本hortonWorks:https://hortonworks.com/
    hortonworks主要是雅虎主导Hadoop开发的副总裁,带领二十几个核心成员成立Hortonworks,核心产品软件HDP(ambari),HDF免费开源,并且提供一整套的web管理界面,供我们可以通过web界面管理我们的集群状态,web管理界面软件HDF网址(http://ambari.apache.org/)
    3、服务收费版本ClouderaManager: https://www.cloudera.com/
    cloudera主要是美国一家大数据公司在apache开源Hadoop的版本上,通过自己公司内部的各种补丁,实现版本之间的稳定运行,大数据生态圈的各个版本的软件都提供了对应的版本,解决了版本的升级困难,版本兼容性等各种问题,生产环境推荐使用。

    Hadoop的模块组成

    1、HDFS:一个高可靠、高吞吐量的分布式文件系统。
    2、MapReduce:一个分布式的离线并行计算框架。
    3、YARN:作业调度与集群资源管理的框架。
    4、Common:支持其他模块的工具模块。

    展开全文
  • 判断一个数是不是质数(素数),3种方式介绍

    万次阅读 多人点赞 2018-06-10 09:56:59
    一、概念介绍 大家中学都学过,就不过多介绍了,大致提两点: 质数又称素数。一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数;否则称为合数。 0和1既不是质数也不是合数,最小的质数...

    一、概念介绍

        大家中学都学过,就不过多介绍了,大致提两点:

    •     质数又称素数。一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数;否则称为合数。
    •     0和1既不是质数也不是合数,最小的质数是2

     

    二、方法介绍

    1.最直观,但效率最低的写法

    public static boolean isPrime(int n){
        if (n <= 3) {
            return n > 1;
        }
        for(int i = 2; i < n; i++){
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

        这里特殊处理了一下小于等于3的数,因为小于等于3的自然数只有2和3是质数。

        然后,我们只需要从2开始,一直到小于其自身,依次判断能否被n整除即可,能够整除则不是质数,否则是质数。

     

    2.初步优化

        假如n是合数,必然存在非1的两个约数p1和p2,其中p1<=sqrt(n),p2>=sqrt(n)。由此我们可以改进上述方法优化循环次数。如下:

    public static boolean isPrime(int n) {
        if (n <= 3) {
            return n > 1;
        }
        int sqrt = (int)Math.sqrt(n);
        for (int i = 2; i <= sqrt; i++) {
            if(n % i == 0) {
                return false;
            }
        }
        return true;
    }

     

    3.继续优化

        我们继续分析,其实质数还有一个特点,就是它总是等于 6x-1 或者 6x+1,其中 x 是大于等于1的自然数。

        如何论证这个结论呢,其实不难。首先 6x 肯定不是质数,因为它能被 6 整除;其次 6x+2 肯定也不是质数,因为它还能被2整除;依次类推,6x+3 肯定能被 3 整除;6x+4 肯定能被 2 整除。那么,就只有 6x+1 和 6x+5 (即等同于6x-1) 可能是质数了。所以循环的步长可以设为 6,然后每次只判断 6 两侧的数即可。

    public static boolean isPrime(int num) {
        if (num <= 3) {
            return num > 1;
        }
        // 不在6的倍数两侧的一定不是质数
        if (num % 6 != 1 && num % 6 != 5) {
            return false;
        }
        int sqrt = (int) Math.sqrt(num);
        for (int i = 5; i <= sqrt; i += 6) {
            if (num % i == 0 || num % (i + 2) == 0) {
                return false;
            }
        }
        return true;
    }

        对于输入的自然数 n 较小时,也许效果不怎么明显,但是当 n 越来越大后,该方法的执行效率就会越来越明显了。
        

    展开全文
  • 几款主流好用的markdown编辑器介绍

    万次阅读 多人点赞 2019-09-14 00:48:05
     实在太困了,就先介绍这么多吧~ ~ ~ (PS:刚接触写博客,发现还真是个累活呀:-P) 最后  markdown编辑器产品非常多,以上只是本人接触过的一些,相信还有很多很好的markdown存在,其实也没必要全都试一遍,...
  • 介绍Latex神器——Overleaf的方法

    万次阅读 2019-09-26 00:57:43
    向大家介绍2个神网站,一个是腾讯在线文档,一个是overleaf 腾讯在线文档就不多介绍了,可以直接百度网址并使用,它有2个亮点,1.特别简洁,高效。2.可以多人在线,共同编辑同一个文档。(在笔者参加研究生数学...
  • stringstream常见用法介绍

    万次阅读 多人点赞 2018-09-10 23:20:54
    本文主要介绍 C++ 中 stringstream 类的常见用法。 1 概述 <sstream> 定义了三个类:istringstream、ostringstream 和 stringstream,分别用来进行流的输入、输出和输入输出操作。本文以 stringstream 为主...
  • 大数据的简要介绍

    万次阅读 2020-10-04 21:25:31
    大数据【介绍】1)大数据是什么2)大数据特点3)大数据能做什么(海量数据背景下)4)大数据项目流程 1)大数据是什么 指数据集的大小超过了现有典型数据库软件和工具的处理能力的数据 2)大数据特点 ①海量化(Volume)...
  • DPDK技术介绍

    万次阅读 2020-11-27 16:43:10
    1. DPDK技术介绍 1) 简介 DPDK全称Intel Data Plane Development Kit,是intel提供的数据平面开发工具集,为Intel architecture(IA)处理器架构下用户空间高效的数据包处理提供库函数和驱动的支持。通俗地说,...
  • Springboot简单介绍

    万次阅读 多人点赞 2018-10-31 20:07:57
    Springboot入门介绍 一、Spring框架概述 1.1 什么是Spring Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作《Expert One-On-One J2EE Development and Design...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,801,168
精华内容 1,120,467
关键字:

介绍