精华内容
下载资源
问答
  • 适合Java开发大数据工具和框架:对大数据的存储和处理需要非SQL存储/处理数据工具,例如,NoSQL数据库,全文搜索引擎,实时流式处理,图形数据库等 Datomic–完全事务,云就绪,分布式数据库,用Clojure编写。 是...

    适合Java开发的大数据工具和框架:对大数据的存储和处理需要非SQL存储/处理数据工具,例如,NoSQL数据库,全文搜索引擎,实时流式处理,图形数据库等

    • Datomic

    –完全事务,云就绪,分布式数据库,用Clojure编写。
    是一个灵活的、基于时间因子的数据库,支持联合查询,具有弹性的可扩展性以及支持ACID事务性。Datomic 提供高可用的、分布式存储服务。

    • Amazon DynamoDB

    –快速,灵活的全面管理NoSQL的数据库服务,适用于任何规模的要求一致性,单位毫秒延迟的应用程序。一种完全托管的 NoSQL 数据库服务,提供快速而可预测的性能,能够实现无缝扩展。
    Oracle Coherence–内存数据网格解决方案,通过提供对常用数据的快速访问,使企业能够可预测地扩展关键任务应用程序。简单来说,Coherence仅支持Java,.NET和C++ API三个版本。

    • CouchDB

    –开源的面向文档的NoSQL数据库,使用JSON存储数据。

    • CouchBase

    –开源分布式的NoSQL面向文档数据库,针对交互式应用程序进行了优化。延后写入和松散存储。基于Apache CouchDB,并整合了GeoCouch。

    • Apache Hadoop

    –用Java编写的开源软件框架,用于分布式存储,并对非常大的数据集进行分布式处理。用户可以在不了解分布式底层细节的情况下,开发分布式程序。充分利用集群进行高速运算和存储。
    HDFS对海量数据进行存储,Mapreduce对海量数据进行计算。

    • HBase

    –开放源代码,非关系型,分布式数据库,采用Google的BigTable建模,用Java编写,并在HDFS上运行。HBase利用Hadoop HDFS作为其文件存储系统,利用Hadoop MapReduce来处理HBase中的海量数据,
    利用Zookeeper做协同服务。

    • Apache Hive

    –在Hadoop之上提供类似SQL的层。是一个基于Hadoop的数据仓库平台。通过hive,可以方便地进行ETL工作。hive定义了一个类似于SQL的查询语言,能够将用户编写的SQL转化为相应的Mapreduce程序基于Hadoop执行。

    • Memcached

    –通用分布式内存缓存系统。是一套分布式快取系统,作为高速运行的分布式缓存服务器,具有以下的特点:协议简单,基于libevent的事件处理,内置内存存储方式。

    • EHCache

    –广泛使用的开源Java分布式缓存。主要面向通用缓存、Java EE和轻量级容器。是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认的CacheProvider。主要特性有:快速简单,
    具有多种缓存策略;缓存数据有两级,内存和磁盘,因此无需担心容量问题;缓存数据会在虚拟机重启的过程中写入磁盘;可以通过RMI、可插入API等方式进行分布式缓存;具有缓存和缓存管理器的侦听接口;
    支持多缓存管理器实例,以及一个实例的多个缓存区域;提供Hibernate的缓存实现。

    • Hazelcast

    –基于Java的开源内存数据网格,提供Java程序员关键任务交易和万亿级内存应用。中的数据是分布式的,每一个member持有部分数据和相应的backup数据。

    • Redis

    –开源(BSD许可)内存数据结构存储,用作数据库,缓存和消息代理。是一个开源的使用ANSI C语言编写的、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。
    Redis 有三个主要使其有别于其它很多竞争对手的特点:Redis是完全在内存中保存数据的数据库,使用磁盘只是为了持久性目的; Redis相比许多键值数据存储系统有相对丰富的数据类型;
    Redis可以将数据复制到任意数量的从服务器中。

    • Apache Cassandra

    –java编写的开源分布式数据库管理系统,最初是由Facebook开发的,旨在处理许多商品服务器上的大量数据,提供高可用性,没有单点故障。是一套开源分布式NoSQL数据库系统。
    集Google BigTable的数据模型与Amazon Dynamo的完全分布式架构于一身。操作命令类似关系数据库的操作,一种流行的分布式结构化数据存储方案。

    • MongoDB

    –最受欢迎的,跨平台的,面向文档的数据库。是一个基于分布式文件存储的数据库,使用C++语言编写。旨在为Web应用提供可扩展的高性能数据存储解决方案。应用性能高低依赖于数据库性能,
    MongoDB则是非关系数据库中功能最丰富,最像关系数据库的。核心优势就是灵活的文档模型、高可用复制集、可扩展分片集群。你可以试着从几大方面了解MongoDB,如实时监控MongoDB工具、
    内存使用量和页面错误、连接数、数据库操作、复制集等。

    • Apache Kafka

    –最初是由LinkedIn开发的高吞吐量,分布式订阅消息系统。是一个开源消息系统项目,由Scala写成。该项目的目标是为处理实时数据提供一个统一、高通量、低等待的平台。
    以一个拥有一台或多台服务器的集群运行着,每一台服务器称为broker。

    • Titan

    –可扩展的图形数据库,优化用于存储和查询包含分布在多机集群上的数百亿个顶点和边的图形。支持不同的分布式存储层:Cassandra 1.1和HBase 0.92。

    • Neo4j

    –在Java中实现的开源图形数据库。是一个高性能的NOSQL图形数据库,它将结构化数据存储在网络上而不是表中。它是一个嵌入式的、基于磁盘的、具备完全事务特性的Java持久化引擎。

    • Apache Storm

    –开源分布式实时计算系统。 是一个能近实时地在数据之上运行用户代码片段的流式数据处理框架。它实际上是一系列连在一起的管道。通常用于简单的分析任务 ,诸如计算,以及清洗,
    使其常规化,并且准备摄入用于长期存储的数据。

    • Apache Spark

    –Apache Software Foundation中最活跃的项目,是一个开源集群计算框架。是一种与 Hadoop 相似的开源集群计算环境,在 Scala 语言中实现的,它将 Scala 用作其应用程序框架。与 Hadoop 不同,Spark 和 Scala 能够紧密集成,
    其中的 Scala 可以像操作本地集合对象一样轻松地操作分布式数据集。相比于hadoop,Spark 启用了内存分布数据集,除了能够提供交互式查询外,它还可以优化迭代工作负载,使它在某些工作负载方面表现得更加优越。

    • Amazon Kinesis

    –AWS上的实时流式传输数据平台。对大量的流数据,连续收集和处理。

    • Akka

    –用于在JVM上构建高并发,分布式和弹性消息驱动应用程序的工具包。是一个用 Scala 编写的库,用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。它已经成功运用在电信行业,系统几乎不会宕机。

    • Apache Solr

    –开源企业搜索平台,用Java编写,来自Apache Lucene项目。是一个独立的企业级搜索应用服务器,它对外提供类似于Web-service的API接口。xml格式的http请求与响应。
    比Lucene更为丰富的查询语言,同时实现了可配置、可扩展并对查询性能进行了优化。

    • Elasticsearch

    –java开发的为云构建的分布式RESTful搜索引擎。是基于Lucene的搜索服务器。它提供了分布式多用户能力的全文搜索引擎,基于RESTful web接口。作为Apache许可条款下的开放源码发布,
    是比较流行的企业级搜索引擎。

    展开全文
  • Java开发搜索引擎自动补全大数据核心系统【站内搜索解决方案】+ 数据库 Java开发百度开放云大数据智能存储系统【百度云计算核心技术】 百度开发云大数据技术:分布式文件系统的高级特性及实战应用
  • 1. 创建java项目,导入坐标 2. 编写Account实体类 3. 编写AccountDao接口和实现类 4. 编写AccountService接口和实现类 5. 编写spring核心配置文件 6. 编写测试代码 1. 创建java项目,导入坐标 <...

    一 转账案例

    需求

    使用spring框架整合DBUtils技术,实现用户转账功能

    1.1 基础功能

    步骤分析

    1. 创建java项目,导入坐标
    2. 编写Account实体类
    3. 编写AccountDao接口和实现类
    4. 编写AccountService接口和实现类
    5. 编写spring核心配置文件
    6. 编写测试代码
    1. 创建java项目,导入坐标
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.15</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    2. 编写Account实体类
    public class Account {
        private Integer id;
        private String name;
        private Double money;
    
        get,set,tostring....
    }
    3. 编写AccountDao接口和实现类
    public interface AccountDao {
        // 转出操作
        public void out(String outUser, Double money);
        // 转入操作
        public void in(String inUser, Double money);
    }
    
    @Repository("accountDao")
    public class AccountDaoImpl implements AccountDao {
    
        @Autowired
        private QueryRunner queryRunner;
    
    
        public void out(String outUser, Double money) {
            String sql="update account set money=money-?where name=?";
    
            try {
                queryRunner.update(sql,money,outUser);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        public void in(String inUser, Double money) {
            String sql="update account set money=money+? where name=?";
            try {
                queryRunner.update(sql,money,inUser);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    4. 编写AccountService接口和实现类

    public interface AccountService {
        public void transfer(String outUser, String inUser, Double money);
    }
    
    @Service("accountService")
    public class AccountServiceImpl implements AccountService {
    
        @Autowired
        private AccountDao accountDao;
    
        public void transfer(String outUser, String inUser, Double money) {
            accountDao.out(outUser,money);
            accountDao.in(inUser,money);
        }
    }
    

    5. 编写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: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.bigload" />
        <!--数据库配置-->
        <context:property-placeholder location="jdbc.properties"/>
        <!--把数据库连接池交给IOC容器-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driverClassName}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
        <!--把queryRunner交给IOC容器-->
        <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
            <constructor-arg name="ds" ref="dataSource" />
        </bean>
    </beans>

    6. 编写测试代码

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:appLicationContext.xml")
    public class SpringTest {
        @Autowired
        public AccountService accountService;
        @Test
        public void test1(){
            accountService.transfer("tom","jerry",100d);
    
        }
    }
    
    7)问题分析

    上面的代码事务在dao层,转出转入操作都是一个独立的事务,但实际开发,应该把业务逻辑控制在一个事务中,所以应该将事务挪到service层。

    3.2 传统事务

    步骤分析
    1. 编写线程绑定工具类
    2. 编写事务管理器
    3. 修改service层代码
    4. 修改dao层代码
    1. 编写线程绑定工具类
    /*** 连接工具类,从数据源中获取一个连接,并将实现和线程的绑定 */
    @Component
    public class ConnectionUtil {
        private ThreadLocal<Connection> threadLocal=new ThreadLocal<>();
    
        @Autowired
        private DataSource dataSource;
    
        /*** 获取当前线程上的连接 ** @return Connection */
        public Connection getThreadConnection() {
            Connection connection = threadLocal.get();
            if(null==connection){
                try {
                    connection = dataSource.getConnection();
                    threadLocal.set(connection);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
    
            }
            return connection;
        }
        /*** 解除当前线程的连接绑定 */
        public void removeThreadConnection() {
            threadLocal.remove();
        }
    }

    2. 编写事务管理器

    /*** 事务管理器工具类,包含:开启事务、提交事务、回滚事务、释放资源 */
    @Component
    public class TransactionManager {
        @Autowired
        private ConnectionUtil connectionUtil;
    
        /*开启事务*/
        public void beginTransaction(){
            try {
                connectionUtil.getThreadConnection().setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        /*提交事务*/
        public void commit(){
            try {
                connectionUtil.getThreadConnection().commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        /*回滚事务*/
        public void rollback(){
            try {
                connectionUtil.getThreadConnection().rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        /*释放资源*/
        public void release(){
            try {
                connectionUtil.getThreadConnection().setAutoCommit(true);
                connectionUtil.getThreadConnection().close();
                connectionUtil.removeThreadConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
    
        }
    }
    

    3. 修改service层代码

        public void transfer(String outUser, String inUser, Double money) {
            try {
                transactionManager.beginTransaction();
                accountDao.out(outUser,money);
    //            int a=1/0;
                accountDao.in(inUser,money);
                transactionManager.commit();
            } catch (Exception e) {
                e.printStackTrace();
                transactionManager.rollback();
            } finally {
                transactionManager.release();
            }
    
        }

    4. 修改dao层代码

    @Repository("accountDao")
    public class AccountDaoImpl implements AccountDao {
    
        @Autowired
        private QueryRunner queryRunner;
    
        @Autowired
        private ConnectionUtil connectionUtil;
    
        public void out(String outUser, Double money) {
            String sql="update account set money=money-?where name=?";
    
            try {
                queryRunner.update(connectionUtil.getThreadConnection(),sql,money,outUser);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        public void in(String inUser, Double money) {
            String sql="update account set money=money+? where name=?";
            try {
                queryRunner.update(connectionUtil.getThreadConnection(),sql,money,inUser);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
    }
    5)问题分析

    上面代码,通过对业务层改造,已经可以实现事务控制了,但是由于我们添加了事务控制,也产生了一个新的问题: 业务层方法变得臃肿了,里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了,违背了面向对象的开发思想。

    Proxy优化转账案例

    我们可以将业务代码和事务代码进行拆分,通过动态代理的方式,对业务方法进行事务的增强。这样就不会对业务层产生影响,解决了耦合性的问题啦!

    常用的动态代理技术
    • JDK 代理 : 基于接口的动态代理技术·:利用拦截器(必须实现invocationHandler)加上反射机制生成 一个代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理,从而实现方法增强
    • CGLIB代理:基于父类的动态代理技术:动态生成一个要代理的子类,子类重写要代理的类的所有不是 final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用,顺势织入横切逻辑,对方法进行 增强

    2.1 JDK动态代理方式

    Jdk工厂类

    @Component
    public class JdkProxyFactory {
        @Autowired
        private AccountService accountService;
    
        @Autowired
        private TransactionManager transactionManager;
    
        public AccountService createAccountServiceJdkProxy() {
            AccountService accountServiceProxy = null;
            accountServiceProxy = (AccountService) Proxy.newProxyInstance(
                    accountService.getClass().getClassLoader(),
                    accountService.getClass().getInterfaces(),
                    new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    Object result = null;
                    try {
                        // 1.开启事务
                        transactionManager.beginTransaction();
                        // 2.业务操作
                        result = method.invoke(accountService, args);
                        // 3.提交事务
                        transactionManager.commit();
                    } catch (Exception e) {
                        e.printStackTrace();
                        // 4.回滚事务
                        transactionManager.rollback();
                    } finally {
                        // 5.释放资源
                        transactionManager.release();
                    }
                    return result;
                }
            });
            return accountServiceProxy;
        }
    }
    

    AccountService

    @Service("accountService")
    public class AccountServiceImpl implements AccountService {
    
        @Autowired
        private AccountDao accountDao;
    
        public void transfer(String outUser, String inUser, Double money) {
    
                accountDao.out(outUser,money);
    //            int a=1/0;
                accountDao.in(inUser,money);
        }
    }

    测试

        @Test
        public void test2(){
            AccountService accountServiceJdkProxy = jdkProxyFactory.createAccountServiceJdkProxy();
            accountServiceJdkProxy.transfer("tom","jerry",100d);
        }

    2.2 CGLIB动态代理方式

    Cglib工厂类
    @Component
    public class CglibProxyFactory {
        @Autowired
        private AccountService accountService;
        @Autowired
        private TransactionManager transactionManager;
    
        public AccountService createAccountServiceCglibProxy() {
            AccountService accountServiceProxy = null;
            /** 参数一:目标对象的字节码对象 * 参数二:动作类,实现增强功能 * */
            accountServiceProxy = (AccountService) Enhancer.create(accountService.getClass(), new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    Object result = null;
                    try {
                        // 1.开启事务
                        transactionManager.beginTransaction();
                        // 2.业务操作
                        result = method.invoke(accountService, objects);
                        // 3.提交事务
                        transactionManager.commit();
                    } catch (Exception e) {
                        e.printStackTrace();
                        // 4.回滚事务
                        transactionManager.rollback();
                    } finally {
                        // 5.释放资源
                        transactionManager.release();
                    }
                    return result;
                }
            });
            return accountServiceProxy;
        }
    }
    

    三 初识AOP

    3.1 什么是AOP

    AOP Aspect Oriented Programming 的缩写,意思为面向切面编程

    AOP OOP(面向对象编程) 的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    这样做的好处是
    1. 在程序运行期间,在不修改源码的情况下对方法进行功能增强
    2. 逻辑清晰,开发核心业务的时候,不必关注增强业务的代码
    3. 减少重复代码,提高开发效率,便于后期维护

    3.2 AOP底层实现

    实际上,AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间,Spring通过动态代理技术动态的生成代理对象,代理对象方法执行时进行增强功能的介入,在去调用目标对象的方法,从而完成功能的增强。

    3.3 AOP相关术语

    Spring AOP 实现底层就是对上面的动态代理的代码进行了封装,封装后我们只需要对需要关注的部分进行代码编写,并通过配置的方式完成指定目标的方法增强。

    在正式讲解 AOP 的操作之前,我们必须理解 AOP 的相关术语,常用的术语如下:

    * Target(目标对象):代理的目标对象

    * Proxy (代理):一个类被 AOP 织入增强后,就产生一个结果代理类

    * Joinpoint(连接点):所谓连接点是指那些可以被拦截到的点。在spring中,这些点指的是方法,因为 spring只支持方法类型的连接点

    * Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

    * Advice(通知/ 增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知 分类:前置通知、后置通知、异常通知、最终通知、环绕通知

    * Aspect(切面):是切入点和通知(引介)的结合

    * Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织 入,而AspectJ采用编译期织入和类装载期织入

    3.4 AOP开发明确事项

    3.4.1 开发阶段(我们做的)

    1. 编写核心业务代码(目标类的目标方法) 切入点
    2. 把公用代码抽取出来,制作成通知(增强功能方法) 通知
    3. 在配置文件中,声明切入点与通知间的关系,即切面

    3.4.2 运行阶段(Spring框架完成的)

    Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行,使用代理机制,动态创建目标对象的代理对象,根据通知类别,在代理对象的对应位置,将通知对应的功能织入,完成完整的代码逻辑运行。

    3.4.3 底层代理实现

    在 Spring 中,框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

    • 当bean实现接口时,会用JDK代理模式
    • 当bean没有实现接口,用cglib实现( 可以强制使用cglib(在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>)

    3.5 知识小结

    * aop:面向切面编程
    * aop底层实现:基于JDK的动态代理 和 基于Cglib的动态代理
    * aop的重点概念:

    • Pointcut(切入点):真正被增强的方法
    • Advice(通知/ 增强):封装增强业务逻辑的方法
    • Aspect(切面):切点+通知
    • Weaving(织入):将切点与通知结合,产生代理对象的过程

    四 基于XML的AOP开发

    4.1 快速入门

    步骤分析

    1. 创建java项目,导入AOP相关坐标
    2. 创建目标接口和目标实现类(定义切入点)
    3. 创建通知类及方法(定义通知)
    4. 将目标类和通知类对象创建权交给spring
    5. 在核心配置文件中配置织入关系,及切面
    6. 编写测试代码

    1. 创建java项目,导入AOP相关坐标

    <dependencies>
            <!--导入spring的context坐标,context依赖aop-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            <!-- aspectj的织入(切点表达式需要用到该jar包) -->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.13</version>
            </dependency>
            <!--spring整合junit-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>

    2. 创建目标接口和目标实现类(定义切入点)

    //接口
    public interface AccountService {
        public void transfer();
    }
    //实现类
    public class AccountServiceImpl implements AccountService {
        
        //切入点
        @Override
        public void transfer() {
            System.out.println("这是一个转账操作");
        }
    }
    
    
    

    3. 创建通知类及方法(定义通知)

    public class myAdvice {
        public void before(){
            System.out.println("前置函数执行了");
        }
    }
    

    4. 将目标类和通知类对象创建权交给spring
    5. 在核心配置文件中配置织入关系,及切面

    <?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">
    
        <!--目标类交给IOC容器-->
        <bean id="AccountService" class="com.bigload.service.impl.AccountServiceImpl"/>
        <!--通知类交给IOC容器-->
        <bean id="myAdvice" class="com.bigload.advice.myAdvice"/>
    
        <aop:config>
            <!--引入通知类-->
            <aop:aspect ref="myAdvice">
                <!--配置目标类的transfer方法执行时,使用通知类的before方法进行前置增强-->
                <aop:before method="before"
                            pointcut="execution(public void com.bigload.service.impl.AccountServiceImpl.transfer())"/>
            </aop:aspect>
        </aop:config>
    </beans>

    6. 编写测试代码 

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:appLicationContext.xml")
    public class sprintTest {
        @Autowired
        private AccountService accountService;
    
        @Test
        public void test1(){
            accountService.transfer();
        }
    }

    4.2 XML配置AOP详解

    4.2.1 切点表达式

    表达式语法:

    execution([修饰符] 返回值类型 包名.类名.方法名(参数))

    • 访问修饰符可以省略
    • 返回值类型、包名、类名、方法名可以使用星号 * 代替,代表任意包名与类名之间一个点 . 代表当前包下的类,两个点 .. 表示当前包及其子包下的类
    • 参数列表可以使用两个点 .. 表示任意个数,任意类型的参数列表

    例如:

    execution(public void com.lagou.service.impl.AccountServiceImpl.transfer())
    execution(void com.lagou.service.impl.AccountServiceImpl.*(..))
    execution(* com.lagou.service.impl.*.*(..))
    execution(* com.lagou.service..*.*(..))

    切点表达式抽取
    当多个增强的切点表达式相同时,可以将切点表达式进行抽取,在增强中使用 pointcut-ref 属性代替pointcut 属性来引用抽取后的切点表达式。

    <aop:config>
      <!--抽取的切点表达式-->
    <aop:pointcut id="myPointcut" expression="execution(* com.lagou.service..*.*(..))"> </aop:pointcut>
      <aop:aspect ref="myAdvice">
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
      </aop:aspect>
    </aop:config>

    4.2.2 通知类型

    通知的配置语法:

     <aop:通知类型 method=“通知类中方法名” pointcut=“切点表达式"></aop:通知类型>

    名称 标签 说明
    前置通知 <aop:before> 用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知 <aop:afterReturning> 用于配置后置通知。指定增强的方法在切入点方法之后执行
    异常通知 <aop:afterThrowing> 用于配置异常通知。指定增强的方法出现异常后执行
    最终通知 <aop:after> 用于配置最终通知。无论切入点方法执行时是否有异常,都会执行
    环绕通知 <aop:around> 用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

    注意:通常情况下,环绕通知都是独立使用的

    4.3 知识小结 

    * aop织入的配置
      <aop:config>
        <aop:aspect ref=“通知类”>
          <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
        </aop:aspect>
      </aop:config>
                               
    * 通知的类型
    前置通知、后置通知、异常通知、最终通知、环绕通知
    * 切点表达式
    execution([修饰符] 返回值类型 包名.类名.方法名(参数))

    五 基于注解的AOP开发

    5.1 快速入门

    步骤分析 

    1. 创建java项目,导入AOP相关坐标
    2. 创建目标接口和目标实现类(定义切入点)
    3. 创建通知类(定义通知)
    4. 将目标类和通知类对象创建权交给spring
    5. 在通知类中使用注解配置织入关系,升级为切面类
    6. 在配置文件中开启组件扫描和 AOP 的自动代理
    7. 编写测试代码

    1. 创建java项目,导入AOP相关坐标

    <dependencies>
            <!--导入spring的context坐标,context依赖aop-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            <!-- aspectj的织入(切点表达式需要用到该jar包) -->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.13</version>
            </dependency>
            <!--spring整合junit-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>

    2. 创建目标接口和目标实现类(定义切入点)

    3. 创建通知类(定义通知)

    4. 将目标类和通知类对象创建权交给spring

    @Service
    public class AccountServiceImpl implements AccountService {
    
        @Override
        public void transfer() {
            System.out.println("这是一个转账操作");
        }
    }

    5. 在通知类中使用注解配置织入关系,升级为切面类 

    @Component
    @Aspect
    public class myAdvice {
        @Before("execution(public void com.bigload.service.AccountService.transfer(..))")
        public void before(){
            System.out.println("前置函数执行了");
        }
    }
    

    6. 在配置文件中开启组件扫描和 AOP 的自动代理

    <?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"
           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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        <!--组件扫描-->
        <context:component-scan base-package="com.bigload"/>
        <!--aop的自动代理-->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>

    7. 编写测试代码 

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:appLicationContext.xml")
    public class sprintTest {
        @Autowired
        private AccountService accountService;
    
        @Test
        public void test1(){
            accountService.transfer();
        }
    }

    5.2 注解配置AOP详解

    5.2.1 切点表达式

    切点表达式的抽取

    @Component
    @Aspect
    public class myAdvice {
        @Pointcut("execution(public void com.bigload.service.AccountService.transfer(..))")
        public void pointTransfer(){
            System.out.println("这句话不执行");
        }
        @Before("myAdvice.pointTransfer()")
        public void before(){
            System.out.println("前置函数执行了");
        }
    }

    5.2.2 通知类型

    通知的配置语法:@通知注解(“切点表达式") 

    名称 标签 说明
    前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
    异常通知 @AfterThrowing 用于配置异常通知。指定增强的方法出现异常后执行
    最终通知 @After 用于配置最终通知。无论切入点方法执行时是否有异常,都会执行
    环绕通知 @Around 用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行

    当前四个通知组合在一起时,执行顺序如下:
    @Before -> @After -> @AfterReturning(如果有异常:@AfterThrowing)

    5.2.3 纯注解配置

    springConf.class 

    @Configuration
    @ComponentScan("com.bigload")
    @EnableAspectJAutoProxy
    public class springConf {
    }
    

     测试

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = {springConf.class})
    public class sprintTest {
        @Autowired
        private AccountService accountService;
    
        @Test
        public void test1(){
            accountService.transfer();
        }
    }
    

    5.3 知识小结 

    * 使用@Aspect注解,标注切面类
    * 使用@Before等注解,标注通知方法
    * 使用@Pointcut注解,抽取切点表达式
    * 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy

    AOP优化转账案例

    依然使用前面的转账案例,将两个代理工厂对象直接删除!改为springaop思想来实现

    6.1 xml配置实现

    1)配置文件
        <!--AOP配置-->
        <aop:config> 
            <!--切点表达式-->
            <aop:pointcut id="myPointcut" expression="execution(* com.bigload.service..*.*(..))"/> 
            <!-- 切面配置 -->
            <aop:aspect ref="transactionManager">
                <aop:before method="beginTransaction" pointcut-ref="myPointcut"/>
                <aop:after-returning method="commit" pointcut-ref="myPointcut"/>
                <aop:after-throwing method="rollback" pointcut-ref="myPointcut"/>
                <aop:after method="release" pointcut-ref="myPointcut"/>
            </aop:aspect>
        </aop:config>
    2)事务管理器(通知)
    // 事务管理器工具类,包括:开启事务、提交事务、回滚事务、释放资源 
    @Component
    public class TransactionManager {
        @Autowired
        ConnectionUtils connectionUtils;
    
        public void begin() {
            try {
                connectionUtils.getThreadConnection().setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        public void commit() {
            try {
                connectionUtils.getThreadConnection().commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        public void rollback() {
            try {
                connectionUtils.getThreadConnection().rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        public void release() {
            try {
                connectionUtils.getThreadConnection().setAutoCommit(true);
                connectionUtils.getThreadConnection().close();
                connectionUtils.removeThreadConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    6.2 注解配置实现

    1)配置文件
    <!--开启组件扫描-->
    <context:component-scan base-package="com.lagou"/>
    <!--开启AOP注解支持-->
    <aop:aspectj-autoproxy/>
    2)事务管理器(通知)
    @Component
    @Aspect
    public class TransactionManager {
        @Autowired
        ConnectionUtils connectionUtils;
    
        @Around("execution(* com.lagou.serivce..*.*(..))")
        public Object around(ProceedingJoinPoint pjp) {
            Object object = null;
            try {
                // 开启事务 
                connectionUtils.getThreadConnection().setAutoCommit(false);
                // 业务逻辑 
                pjp.proceed();
                // 提交事务 
                connectionUtils.getThreadConnection().commit();
            } catch (Throwable throwable) {
                throwable.printStackTrace();
                // 回滚事务 
                try {
                    connectionUtils.getThreadConnection().rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            } finally {
                try {
                    connectionUtils.getThreadConnection().setAutoCommit(true);
                    connectionUtils.getThreadConnection().close();
                    connectionUtils.removeThreadConnection();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            return object;
        }
    }
            

     

    展开全文
  • 现在已经从之前的java后端开发正式转大数据开发项目数据50T,日均数据增长20G左右,大概是需求问题吧,工资待遇较上一份翻了一倍(这是重点)。 当然,我的分享不是能让各位升职加薪跳槽,只是对于技术人来说,技多...

    Java开发转大数据开发要做到几点?假设你有Java基础选择了自学大数据,而对于完全没有编程和Java基础的人来说,自学绝对是浪费时间和精力的事情。

    现在已经从之前的java后端开发正式转大数据开发,项目数据50T,日均数据增长20G左右,大概是需求问题吧,工资待遇较上一份翻了一倍(这是重点)。

    当然,我的分享不是能让各位升职加薪跳槽,只是对于技术人来说,技多不压身,以下为个人经验分享,不喜勿喷。主要讲大数据的职业规划方向、大数据开发工程师需get技能、如何系统的学习。

    一、大数据的职业规划方向

    学习目的在于工作上的运用,大数据工程师需get技能总结如下:

    01.Linux基本操作

    02.python&爬虫介绍

    03.hadoop分布式集中

    04.离线数据处理

    05.实时数据处理

    06.ETL与环境相关

    07.大数据应用与数据挖掘

    08.java高级(虚拟机、并发)

    09…HBase(JavaAPI操作+Phoenix)

    10.Kafka

    11.Spark(Core+sparksql+Sparkstreaming)

    12.CDH集群

    二、如何系统的学习

    我本人是17年年初开始自学,自学了Linux基本操作,这个很好学,领悟能力还可以就看书,不行就看视频重复看,大概一周可以搞定。

    然后就学习了CDH集群搭建,Python爬虫,我是java后端开发,这些网上找点资料看点书,很好学,上手也很快。

    这里重点推荐《深入理解Java虚拟机》、《Java高并发实战》必看书籍。

    然后我就停留在这一阶段,停了1个多月的学习计划,后面公司同事离职跳槽跟女友吵架分手等等遇到一些事情,我又想起还是要规划下自己的职业生涯,顺手报了个培训班,遇到了还算不错的老师,这个学习周期3个月就算结业了。计划是想熬完过年再跳,跳槽的人都知道的,金三银四~

    这里提醒一下,如果你觉得自己看书效率太慢,或者容易思维不通的情况,你可以在网上搜集一些课程,跟着课程走也OK。这个完全根据自己情况决定。如果看书效率不高就很网课,相反的话就自己看书。自制力不强的人就没什么好推荐的,你什么都不适合学。
       人工智能、大数据、云计算和物联网的未来发展值得重视,均为前沿产业,多智时代专注于人工智能和大数据的入门和科谱,在此为你推荐几篇优质好文:
    1.在学习大数据之前,需要具备什么基础
    http://www.duozhishidai.com/article-12916-1.html
    2.大数据工程师培训,需要学习的有哪些课程?
    http://www.duozhishidai.com/article-15081-1.html
    3.大数据的特点是什么,大数据与Hadoop有什么关系?
    http://www.duozhishidai.com/article-13276-1.html


    多智时代-人工智能大数据学习入门网站|人工智能、大数据、物联网云计算的学习交流网站

    多智时代-人工智能大数据学习入门网站|人工智能、大数据、云计算、物联网的学习服务的好平台

    展开全文
  • 3 独立完成个人承担模块或项目开发和测试     任职要求 重点大学本科及以上学历,计算机相关专业优先 有3年以上JAVA WEB开发工作经验;有高访问量,高负载网站系统开发经验者优先 1、 精通Java Cor

    java工程师-互联网方向

    工作职责

    1 参与产品需求分析、网站系统的设计方案;

    2 参与、协助项目组长共同完成或带领项目小组承担任务的系统功能设计和数据库设计

    3 独立完成个人承担模块或项目的开发和测试

     

     

    任职要求

    重点大学本科及以上学历,计算机相关专业优先

    有3年以上JAVA WEB开发工作经验;有高访问量,高负载网站系统开发经验者优先

    1、 精通Java Core/数据结构及算法/J2EE/Struts2/WebWork 2/JSP/Servlet/Java TCP/IP Socket/Ajax/JavaScript/Xml等WEB系统开发技术;

    2、 精通SQLSERVER/MYSQL等数据库,熟练编写存储过程;

    3、 精通在Linux系统下的应用环境部署及性能优化;

    4、 具备较强的面向对象系统分析、系统设计经验;精通面向对象分析设计,熟悉设计模式

    积极主动,能承受高度工作压力,具有良好的信息收集能力、归纳思维能力、团队协作意识强。


    Android工程师

    陆金所:

    工作职责:

    1. 参与Andorid平台产品的核心框架的设计和改进;

    2. 参与项目技术难点攻关;

    3. 完成Android平台产品的开发工作;

    4. 实现与服务器端的接口交互;

    5. 负责部分服务器端的接口实现;

    6. 配合测试人员进行自动化测试;

     

    任职要求:

    1. 投入敬业,良好的沟通协作意识,较强的问题解决能力;

    2. 3年左右Android平台开发经验;

    3. 有J2EE经验,熟悉CORE JAVA,熟悉Hibernate、Sprint、Struts等主流框架;

    4. 良好的编程习惯,精通数据结构和面向对象程序设计,有兴趣和能力编写高效而整洁的代码;

    5. 精通Android平台及框架原理以及应用程序的设计和开发;

    6. 精通Android自定义UI的实现;

    7. 熟悉Android App的性能优化和安全防护策略;

    8. 了解hybird app研发,熟悉html5、javascript和css;

    9. 对改进移动端用户体验有自己的见解;

    10. 有实际Android App上架经验,了解国内Android主流发布渠道;

    11. 本科及以上学历,双证齐全


    大数据hadoop应用开发

    大数据应用开发工程师:

    岗位职责

    1.从事hadoop相关的数据平台开发工作

    2.编写API接口对外提供用户标签数据和推荐结果

    3.开发和设计流计算系统,满足业务实时的数据需求

    4.与算法研究工程师一起研究和分析数据的本来面目,推荐用户更有价值的信息。

     

    能力要求

    1.本科以上学历,5年以上工作经验, 精通JAVA

    2.有过大数据分析(SAS)、数据仓库(ETL)开发经验的优先

    3.熟悉hadoop,storm,flume,hive,pig,python,php,redi其中一种以上的优先考虑

    4.有项目管理经验的优先考虑


    算法工程师

    能力要求

    重点大学硕士以上学历

    1.      能熟练使用Java或C++编程

    2.      有很强的算法理论研究经验并发表过相关论文

    3.      熟悉数据挖掘和机器学习

    4.熟悉Hadoop并有Map/Reduce开发经验者优先

    5.有良好的沟通能力、学习能力及团队合作精神,热爱数据分析和算法研究。

    有满足上面职位要求,想应聘的发送简历到2826828725@qq.com, 我们详谈,谢谢!

    展开全文
  • + Java 后端技术学习指南】:一份通向理想互联网公司的面试指南,包括 Java,技术面试必备基础知识、Leetcode、计算机操作系统、计算机网络、系统设计、分布式、数据库(MySQL、Redis)、Java 项目实战等, 新鲜出炉...
  • 大数据已成为当下互联网领域的炙热话题,那么一些想朝大数据发展...学习内容:Java 语言入门 → OOP 编程 → Java 常用Api、集合 → IO/NIO → Java 实用技术 → Mysql 数据库 → 阶段项目实战 → Linux 基础 → she...
  • AVRO原本是Hadoop的子组件,后来被独立出来成为了一个单独的项目 二、序列化 序列化:将某一个对象按照指定规则转化为对应形式的数据 - 如果将对象序列化之后存储到磁盘上,这个过程称之为持久化 - 持久化本质上...
  • 探花交友2020ava大数据实战,全新项目,中高级开发推荐学习, 附上实战学习资料,供学习交流!
  • 主要是记录我学习Linux、Python爬虫、数据分析、机器学习、Java大数据开发过程中遇到的一些挺不错的资源(含个人笔记、书籍、视频资源、GitHub上相关项目等等),如下图所示 如果你有更好的资源,欢迎前来pull ...
  • 对于普通在校大学生来说,参加岗前实训能够有效的把理论和实践结合起来,快速获得动手...即使有的大数据框架不是使用Java开发(例如spark),但是其还是运行在Java虚拟机上,那么Java就成了大数据时代的项目实战首...
  • 大概在三月份开始面了几家互联网公司,主要方向是java后端和大数据开发,最近整理学习资料,所以分享一下美团,滴滴,蘑菇街等公司的面经。 美团 一面 聊你最熟悉的项目和技术。 项目中为什么要使用spark。 spark...
  • 开发后来贡献给了Apache的一套用于进行分布式协调和管理的框架 Zookeeper原本是Hadoop的子组件,后来独立出来成为一个单独的顶级项目 Zookeeper是一个中心化的服务(注册中心):统一配置、统一命名、分布式锁(解决了...
  • 大数据研发经理 薪资:30-40K 职位描述: 1、负责公司大数据平台的规划与建设。 2、组建大数据领域技术团队,以数据为依据向运营提供决策建议。 3、负责机器学习产品总体架构,攻克技术难关和主导关键技术决策。 4、...
  • 从一个初入行的程序员的角度来看前端入门很简单,要终了项目理论所需的效果很难,需求对CSS和JS有很深化的晓得,何况如今的前端工程师都需求会一些前端的构造以跋涉开发速度,并且前端像是Node.js直接能够树立效劳器...
  • java大数据、多线程及高并发的处理方案一、数据量太大获取缓慢怎么办? 一、数据量太大获取缓慢怎么办? 貌似这个问题在所有开发的应用系统中都会碰到这个问题,随着时间的推移,由于需求的不断演变,项目的数据量...
  • Java企业级平台开发任务当中,持久层框架的选择,Mybatis和Hibernate都占据一定的市场。从大趋势来说,传统企业偏爱Hibernate,而互联网更偏爱Mybatis。今天的大数据基础分享,我们就来对Mybatis和Hibernate两个...
  • 前言 ...其实这个问题很好解决,如果你在开发中很少能够遇见需要Spring扩展时,不妨把目光放到一些依托于Spring的项目,看看它们是如何运用Spring的扩展点的。对于Spring的学习,我认为最终真正学会的
  • 原来Java大数据才是真正的高富帅!

    千次阅读 2019-05-02 12:23:07
    国内大多数大型互联网公司的程序员被称作研发工程师,但实际上国内几乎没有研发项目,只能叫做开发开发程序员的工作大多是重复性劳动,容易产生疲惫感,薪资在工作2-5年内就达到了一个峰值,再要提升就比较困难,...
  • 国内大多数大型互联网公司的程序员被称作研发工程师,但实际上国内几乎没有研发项目,只能叫做开发开发程序员的工作大多是重复性劳动,容易产生疲惫感,薪资在工作2-5年内就达到了一个峰值,再要提升就比较困难,...
  • 大数据开发学习路线

    2020-11-20 21:55:54
    怪不得咱这里的小伙伴们个个都磨拳擦掌,都嚷嚷着想从事大数据相关的开发工作,问能不能整一个大数据开发相关的技术学习路线和知识点大梳理。 得嘞,你们就负责冲,学习路线俺来安排! 注:本文已收录于...
  • 大数据、算法项目在任何大厂无论是面试还是工作运用都是非常广泛的,我们精选了50个百度、腾讯、阿里等大厂的大数据、算法落地经验甩给大家,千万不要做收藏党哦,空闲时间记得随时看看! 如果你没有大厂项目经验,...
  • 国内大多数大型互联网公司的程序员被称作研发工程师,但实际上国内几乎没有研发项目,只能叫做开发开发程序员的工作大多是重复性劳动,容易产生疲惫感,薪资在工作2-5年内就达到了一个峰值,再要提升就比较困难...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,202
精华内容 480
关键字:

java大数据开发项目

java 订阅