您的位置:新葡亰496net > 网络数据库 > 新葡亰496net:java开辟常用技艺,Server数据库的积

新葡亰496net:java开辟常用技艺,Server数据库的积

发布时间:2019-12-10 14:08编辑:网络数据库浏览(80)

     

    在一些先决条件下,SQL Server可以缓存临时表(cache Temp Tables)。缓存临时表意味着当你创建反复创建同个临时表时,SQL Server就可以重用它们。这会从整体上大幅度提高你的工作量(性能),因为SQL Server不需要访问内存里的特定页(PFS,GAM,SGAM),经常访问这些页在工作量大的情况下会引起加锁竞争(Latch Contention)。Paul White有一篇很棒的文章详细描述这个情况,可以点此围观下。

    --==========================================================================

    java开发常用技术,java开发

    1.事件简介

    本文出处: 

    临时表缓存的条件之一是不能在存储过程里混合使用DML(Data Manipulation Language 数据操作语言)和DDL(Data Definition Language 数据定义语言)语句。我们来看下面的代码:

    在博客园看到一篇文章《SQLServer Temp tables 数据疑问》,文章中问道在没有任何负载情况下,还有大量的临时表,这是为什么?

    基础部分

        事件(event)是MySQL在相应的时刻调用的过程式数据库对象。一个事件可调用一次,也可周期性的启动,它由一个特定的线程来管理的,也就是所谓的“事件调度器”。

     

     1 -- Create a new stored procedure
     2 CREATE PROCEDURE PopulateTempTable
     3 AS
     4 BEGIN
     5     -- Create a new temp table
     6     CREATE TABLE #TempTable
     7     (
     8         Col1 INT IDENTITY(1, 1),
     9         Col2 CHAR(4000),
    10         Col3 CHAR(4000)
    11     )
    12 
    13     -- Create a unique clustered index on the previous created temp table
    14     CREATE UNIQUE CLUSTERED INDEX idx_c1 ON #TempTable(Col1)
    15 
    16     -- Insert 10 dummy records
    17     DECLARE @i INT = 0
    18     WHILE (@i < 10)
    19     BEGIN
    20         INSERT INTO #TempTable VALUES ('Woody', 'Tu')
    21         SET @i  = 1
    22     END
    23 END
    24 GO
    

    --==========================================================================

    1. 线程和进程的区别

    线程三个基本状态:就绪、执行、阻塞

    线程五个基本操作:创建、就绪、运行、阻塞、终止

    进程四种形式:主从式、会话式、消息或邮箱机制、共享存储区方式

    进程是具有一定功能的程序关于某次数据集合上的一次运行活动,是系统进行资源分配和调度的一个独立单位。一个进程包含多个线程。

    线程是进程的一个实体,是CPU调度和分配的基本单元。

        事件和触发器类似,都是在某些事情发生的时候启动。当数据库上启动一条语句的时候,触发器就启动了,而事件是根据调度事件来启动的。由于他们彼此相似,所以事件也称为临时性触发器。

     

    这里你通过DDL语句(CREATE UNIQUE CLUSTERED INDEX )创建了索引,这就是说你混合使用了DDL和DML语句。因此SQL Server不能缓存你的临时表。你可以从下面例子里的DMV sys.dm_os_performance_counters ,通过跟踪性能计数器Temp Tables Creation Rate 来验证:

    让我们来实验探索下

    2. JSP四大域对象和九大内置对象

    四大域对象:PageContext、request、session、servletContext

    九大内置对象:request、response、application、config、Exception、page、out、pageContext、session

        事件取代了原先只能由操作系统的计划任务来执行的工作,而且MySQL的事件调度器可以精确到每秒钟执行一个任务,而操作系统的计划任务(如:Linux下的CRON或Windows下的任务计划)只能精确到每分钟执行一次。

    问题背景

     1 DECLARE @table_counter_before_test BIGINT;
     2 SELECT @table_counter_before_test = cntr_value FROM sys.dm_os_performance_counters
     3 WHERE counter_name = 'Temp Tables Creation Rate'
     4 
     5 DECLARE @i INT = 0
     6 WHILE (@i < 1000)
     7 BEGIN
     8     EXEC PopulateTempTable
     9     SET @i  = 1
    10 END
    11 
    12 DECLARE @table_counter_after_test BIGINT;
    13 SELECT @table_counter_after_test = cntr_value FROM sys.dm_os_performance_counters
    14 WHERE counter_name = 'Temp Tables Creation Rate'
    15 
    16 PRINT 'Temp tables created during the test: '   CONVERT(VARCHAR(100), @table_counter_after_test - @table_counter_before_test)
    17 GO
    

    首先选择任何一个用户数据库,执行以下脚本:

    3. 使用final关键词修饰一个变量的时候是引用不能变还是引用的对象不能变?

    Final关键词修饰一个变量是指引用变量不能变。引用变量所指对象的内容是可以变化的。

    2 事件的优缺点
        2.1 优点

    在写SQL Server存储过程中,如果存储过程中定义了临时表,
    有些人习惯在存储过程结束的时候一个一个显式地删除过程中定义的临时表(drop table #tName),有些人又没有这个习惯,
    对于不明真相的群众或者喜欢思考的人会问,存储过程中定义的临时表,最后要不要主动删除,为什么?
    或者说是不是存储过程结束的时候删除临时表更加规范?
    不止一个人问过这个问题了,说实在话,本人之前确实不清楚,只是认为,显式删掉或者不删都行,临时表在当前Session断开之后会自动释放
    那么存储过程中定义的临时表,在使用完之后,到底删还是不删?显式删除与不做删除有无区别?
    本文将对此问题进行一个粗浅的分析,如有不对的地方,还望指出,谢谢。

    当你运行这个代码时,SQL Server需要创建1000个单独的临时表,这个从SSMS的输出窗口就可以看到。

    CREATE PROCEDURE USP_TempTableTest
    AS
    BEGIN
        SET NOCOUNT ON;
    
        CREATE TABLE #TB1(C11 INT,C22 INT)
        INSERT INTO #TB1
        SELECT 1,1
    
        SELECT * FROM #TB1
    END
    GO
    
    EXEC USP_TempTableTest
    

    4. Private、protected、public的区别

    private:
    继承成员但没有访问权限。(可以通过此类中的protected成员函数和public成员函数访问。)
    protected:
    继承成员,有访问权限,类外没有访问权限,不可将继承的protected修改为private.
    public:
    继承成员,有访问权限,类外有访问权限。

        一些对数据定时性操作不再依赖外部程序,而直接使用数据库本身提供的功能。

     

    新葡亰496net 1 

    按照通用的理解,存储过程中的临时表会在调用中创建,在存储过程调用结束后释放,存储过程执行结束后,我们不应该在tempdb中找到#TB1开头的临时表。

    5. 父类和子类都有静态代码块时,创建子类是先执行哪类?

    静态代码块在JVM加载类的时候先执行,父类先于子类执行。

        可以实现每秒钟执行一个任务,这在一些对实时性要求较高的环境下就非常实用了。

    存储过程中临时表的表结构也有缓并且会被重用

    通过PRIMARY KEY约束来强制UNIQUE CLUSTERED INDEX就很容易克服这个问题。在这个方式下,你没有混合使用DDL和DML语句,SQL Server最后也能缓存你的临时表。

    让我们来检查下

    6. Junit中before和beforeclass的区别

    Before 在每个测试方法之前都会运行一次,只需要声明public

    BeforeClass 在类中只运行一次,必须声明成public static

        2.2 缺点
        定时触发,不可以调用。

    那么到底需不需要显式删除,显式删除或者是不删除有什么区别?
    这中间涉及到一个临时表缓存的知识点,首先看什么是临时表的缓存。
    缓存临时表是SQL SERVER 2005以来的一个新特性,
    临时表的创建时需要往临时库系统表中写入数据(元数据,临时表的表结构信息),跟普通的增删改操作一样,这个过程需要一定的资源消耗
    在满足一定条件的情况下(后面说需要满足的条件是什么),
    每当用户请求完成之后(当然这个用户请求的SQL中包含了临时表),临时表的元数据将会保存在临时库(tempdb)的系统表中
    虽然在用户看来,当前Session创建的临时表,对其他Session事不可见的,在Session断开或者临时表被删除(drop)之后,将不可访问。
    但是当新的Session调用同样的包含了创建临时表的代码,SQL Server内部会重用之前Session执行时创建过的临时表,而无需再次定义临时表。
    这样的话可以节约一些创建表的步骤所消耗的资源。

     1 ALTER PROCEDURE PopulateTempTable
     2 AS
     3 BEGIN
     4     -- Create a new temp table
     5     CREATE TABLE #TempTable
     6     (
     7         Col1 INT IDENTITY(1, 1) PRIMARY KEY, -- This creates also a Unique Clustered Index
     8         Col2 CHAR(4000),
     9         Col3 CHAR(4000)
    10     )
    11 
    12     -- Insert 10 dummy records
    13     DECLARE @i INT = 0
    14     WHILE (@i < 10)
    15     BEGIN
    16         INSERT INTO #TempTable VALUES ('Woody', 'Tu')
    17         SET @i  = 1
    18     END
    19 END
    20 GO
    
    use tempdb
    go
    --======================================
    --查看临时表的列
    SELECT OBJECT_NAME(OBJECT_ID) AS ObjName,
    * FROM SYS.all_columns
    WHERE OBJECT_NAME(OBJECT_ID) LIKE '%#%'
    

    7. 单例模式

    public class Singleton {  

        private static Singleton sl;  

        private Singleton (){}  

        public static synchronized Singleton getInstance() {  

        if (sl== null) {  

            sl= new Singleton();  

        }  

        return sl;  

        }  

    }  

    3 创建事件

     

    当你重新执行刚才用来跟踪相关计数器的代码,可以看到SQL Server值创建了一次临时表并重用它了:

    运行以上代码,可以很容易找到:
    新葡亰496net 2

    8. Redis数据结构

    String-字符串 Hash-字典 list-列表 set-集合 sorted set-有序集合

        一条create event语句创建一个事件。每个事件由两个主要部分组成,第一部分是事件调度(event schedule),表示事件何时启动以及按什么频率启动,第二部分是事件动作(event action ),这是事件启动时执行的代码,事件的动作包含一条SQL语句,它可能是一个简单地insert或者update语句,也可以使一个存储过程或者 benin...end语句块,这两种情况允许我们执行多条SQL。

    上面是理论,下面来做个小实验演示上面的理论,首先来看不同Session之间临时表“重用”的现象。
    首先这里要借助系统视图sys.dm_os_performance_counters 来判断临时表的创建次数,该系统表中计数器的名称为:Temp Tables Creation Rate。

    新葡亰496net 3

    新葡亰496net,列名C11和C22和我们存储过程中定于的临时表列名一样,只是换了个马甲而已,别告诉我换了马甲你们就不认识”它“咯

    9. HashMap、HashSet和HashTable的区别

    HashMap基于Map接口实现,线程非同步所以不安全。键是唯一不可重复的,但是value值可以重复且允许空值存在。

    新葡亰496net:java开辟常用技艺,Server数据库的积累进程中定义的有时表。HashTable是基于Dictionary类实现,线程默认同步所以是安全的,键值唯一且不为空,value值不能为空值。

    HashSet是基于set实现的,以对象作为元素,且拒绝重复对象。内部使用HashMap实现,其实就是HashMap的一个视图。

        一个事件可以是活动(打开)的或停止(关闭)的,活动意味着事件调度器检查事件动作是否必须调用,停止意味着事件的声明存储在目录中,但调度器不会检查它是否应该调用。在一个事件创建之后,它立即变为活动的,一个活动的事件可以执行一次或者多次。

    创建如下存储过程,存储过程中定义了一个临时表,

     

    --================================================================

    10. ArrayList和LinkedList的区别

    ArrayList是基于动态数组的数据结构,查询较快

    LinkedList是基于链表的数据结构,因为不需要移动数据,所以增删较快。

        3.1 创建语法如下

    create procedure Proc_TestTempTable
    as
    begin
    
        create table #t20170413
        (
            col_1 varchar(100) ,
            col_2 varchar(100)
        )
    
        insert into #t20170413 values ('aaa','bbb');
    
        select * from #t20170413
        --select * from tempdb.sys.tables where name like '#t20170413%'
    end
    

    这个结论也意味着,当你创建额外的非聚集索引(Non-Clustered Indexes)时,SQL Server也不能缓存临时表,因为在你的存储过程里,你又一次混合使用DDL和DML语句。

    解释:

    11. 线程中wait和sleep的区别

    Wait方法属于Object类,使线程放弃进入执行,进入线程等待池,只能使用notify或notifyAll方法才能唤醒此线程,线程会等待进入线程池。即使在执行此方法时,线程已进入线程池,依然会放弃执行,让出线程池,交出锁。即使线程被激活,也需要等待前方线程执行完毕后才可进入线程池执行。

    Sleep方法属于Thread类,使线程在指定时间内暂停执行,让cup暂时执行其他线程,但这个线程的监控状态依然保持,当执行时间到了以后,该线程恢复到之前状态,继续执行,线程不会释放锁。

        CREATE  
            [DEFINER = { user | CURRENT_USER }]  
            EVENT  
            [IF NOT EXISTS]  
            event_name  
            ON SCHEDULE schedule  
            [ON COMPLETION [NOT] PRESERVE]  
            [ENABLE | DISABLE | DISABLE ON SLAVE]  
            [COMMENT 'comment']  
            DO event_body;  
    
        schedule:  
            AT timestamp [  INTERVAL interval] ...  
          | EVERY interval  
            [STARTS timestamp [  INTERVAL interval] ...]  
            [ENDS timestamp [  INTERVAL interval] ...]  
    
        interval:  
            quantity {YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |  
                      WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |  
                      DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}  
    

    在存储过程创建之后,第一次执行的时候,来观察一个现象,如下截图

    但在SQL Server 2014里,你就可以克服这个限制,因为现在你可以在CREATE TABLE语句行里创建索引。来看下面的代码:

    上面看到的#A2206DOC这个临时表并不是我们存储过程中使用到的#TB1,但是但是两者存在一定关联。想象一下,每次存储过程执行,都需要创建和释放临时表,而创建和释放临时表又涉及到修改很多系统表的数据,而如果缓存这个临时表,那么下一次调用存储过程时,就避免创建和释放临时表所照成的资源消耗,从而达到一定的性能提升。

    12. Equals和==的区别

    ==是一个运算符,是逻辑上的判断,比较的是引用地址。

    Equals是String的一个方法,是比较引用地址,在Object类时,Equals和==是一样的,对于其他类来说如果重新了Equals方法,则比较的两个对象的数据内容。

     

    新葡亰496net 4

     1 ALTER PROCEDURE PopulateTempTable
     2 AS
     3 BEGIN
     4     -- Create a new temp table
     5     CREATE TABLE #TempTable
     6     (
     7         Col1 INT IDENTITY(1, 1) PRIMARY KEY, -- This creates also a Unique Clustered Index
     8         Col2 CHAR(100) INDEX idx_Col2,
     9         Col3 CHAR(100) INDEX idx_Col3
    10     )
    11 
    12     -- Insert 10 dummy records
    13     DECLARE @i INT = 0
    14     WHILE (@i < 10)
    15     BEGIN
    16         INSERT INTO #TempTable VALUES ('Woody', 'Tu')
    17         SET @i  = 1
    18     END
    19 END
    20 GO
    

     专业解释:

    13. HashCode和Equals

    HashCode和Equals都是在Object类中定义的,是对两个对象地址的比较,如果重写了Equals方法就必须重写HashCode方法。

    HashCode方法返回的是对象的散列码,返回值是int类型的散列码;Equals返回的是true和false。

    如果两个对象相同,他们的HashCode值必须相同;如果两个对象的HashCode值相同,他们不一样相同。

        名词解释:

    很明显,sys.dm_os_performance_counters系统表中的Temp Tables Creation Rate计数器加了1,也就是说在执行存储过程中过程中发生了一次临时表的创建动作
    然后继续再次执行上面的代码

    如你所见,我在创建临时表本身的时候,就在临时表上直接创建2个额外的非聚集索引。又一次我们没有混合使用DDL和DML语句,SQL Server又一次可以缓存并重用你的临时表。

    SQL Server删除一个临时对象时,不移除该对象的条目,当再次使用时,就无须重新创建临时对象,SQL Server为临时对象缓存一个数据页和一个IAM页,并回收剩余页,如果临时表的大小超过8MB,回收会异步进行。

    14. 方法重载和重写的区别

    方法重载:在同一个类中,方法名称相同,参数类型和个数不同,返回值也可以不同。

    方法重写:父子类、接口和实现类之间的关系,子类可以重写父类方法,但是参数个数、类型、返回值必须相同。

        event_name :创建的event名字(唯一确定的)。
        ON SCHEDULE:计划任务。
        schedule: 决定event的执行时间和频率(注意时间一定要是将来的时间,过去的时间会出错),有两种形式 AT和EVERY。
        [ON COMPLETION [NOT] PRESERVE]: 可选项,默认是ON COMPLETION NOT PRESERVE 即计划任务执行完毕后自动drop该事件;ON COMPLETION  PRESERVE则不会drop掉。
        [COMMENT 'comment'] :可选项,comment 用来描述event;相当注释,最大长度64个字节。
        [ENABLE | DISABLE] :设定event的状态,默认ENABLE:表示系统尝试执行这个事件, DISABLE:关闭该事情,可以用alter修改
        DO event_body: 需要执行的sql语句(可以是复合语句)。CREATE EVENT在存储过程中使用时合法的。

    新葡亰496net 5

    新葡亰496net 6 

    --==================================================================

    15. Junit中before和beforeclass的区别

    Before是初始化方法,在每个程序运行之前都会执行一次。

    Beforeclass在类中只运行一次。

        3.2 开启关闭事件调度器

    同样的代码,这一次sys.dm_os_performance_counters系统表中的Temp Tables Creation Rate计数器没有加1,
    为什么明明是存储过程中定义了临时表,上面执行一次,Temp Tables Creation Rate加1,然后再次执行就不加1了?
    这个就是临时表重用的现象(严格说是临时表的表结构或者表定义,而不包含数据),
    因为第一次执行存储过程的时候创建了临时表,然后再次执行存储过程的时候就重用了第一次的临时表。  

    在SQL Server 2014里,在临时表上定义行内定义索引,避开混合使用DML和DDL语句,让临时表只创建一次并重用,是一个很棒的功能!

    问题1: 多个存储过程并发调用的时候怎么办?

    16. STAR法则

    Situation: 事情是在什么情况下发生

    Task: 你是如何明确你的任务的

    Action: 针对这样的情况分析,你采用了什么行动方式

    Result: 结果怎样,在这样的情况下你学习到了什么

            3.2.1 MySQL事件调度器event_scheduler负责调用事件,它默认是关闭的。这个调度器不断地监视一个事件是否要调用, 要创建事件,必须打开调度器。

      那怎么证明该存储过程第二次执行的时候重用了第一次创建的临时表?
    新葡亰496net:java开辟常用技艺,Server数据库的积累进程中定义的有时表。  对存储过程稍作修改,存储过程中加一句代码,查询临时库中该临时表信息

    这个新功能怎样?欢迎在下面评论里告诉我。 

    当并发调用时,会生成多个类似的临时表”缓存“以供调用,并保证一个临时表”缓存“在一个时间点内只能被一个回话执行的存储过程访问到,在访问结束后,会清理该临时表”缓存“的数据,然后供下一个回话使用。

    17. Cookie和Session的区别

    cookie数据存储在客户的浏览器上,cookie是不安全的,别人可以分析存放在本地cookie并进行cookie欺骗;

    Session存储在服务器上,Session是安全的;当访问增多时,Session会占用服务器性能,可以考虑使用cookie

    建议将登陆信息等重要信息保存在Session中,其他需要保留的信息可以存在cookie中。

        mysql> show variables like '%event_scheduler%';  
         ----------------- -------   
        | Variable_name   | Value |  
         ----------------- -------   
        | event_scheduler | OFF   |  
         ----------------- -------   
    

    新葡亰496net 7

    参考文章:

    https://www.sqlpassion.at/archive/2013/06/27/improved-temp-table-caching-in-sql-server-2014/

     

    18. JQuery有哪些选择器

    ID选择器、类选择器、层次选择器、组合选择器、属性选择器、表单选择器等等

     

      然后执行两次如下代码,下面截图是第二次执行的结果(下面会做解释为什么是第二次的执行的结果),
      在临时表被重用的时候查询出来当前临时表的信息,发现临时表创建次数并没有增加,也就是说临时表被重用了

    问题2: 什么样的临时表会被”缓存“

    19. 事务的特性和隔离级别

    特性:原子性、一致性、隔离性、持久性。

    隔离级别:

     ① Serializable (串行化):可避免脏读、不可重复读、幻读的发生。

     ② Repeatable read (可重复读):可避免脏读、不可重复读的发生。

     ③ Read committed (读已提交):可避免脏读的发生。

     ④ Read uncommitted (读未提交):最低级别,任何情况都无法保证。

            3.2.2 开启事件调度器

    新葡亰496net 8

    当然不是所有临时表都会被缓存,需要满足一定的条件:

    20. POI上传数据量过大

    可分批处理  先行保存部分内容至数据库,再清空list集合,重新导入内容

            通过命令行

      既然说临时表重用了,那么临时表一定存在于临时库的系统表中,那么如何证明这个存储过程的临时表在临时库中呢?
      上面显示的临时表的Id是-1297292959,那么这里就临时库中查询Id = -1297292959的表信息,发现果然存在这个一张表。
      临时库中的这个表信息除了名字和modify_date不一样,modify_date据观察是临时表被重用的时间,也就是临时表被重用一次就修改一次modify_date
      其他信息完全一致,这就是说明,存储过程第一次执行完成之后,它所创建的临时表被缓存了起来(至于名字不同,后面再解释),
      当再次执行该存储过程的时候可以重用第一次执行存储过程时候创建的临时表的表结构。

    1. 没有创建命名约束

    21. 前缀编码

    在一个字符集中,任何一个字符的编码都不是另一个字符编码的前缀。

            可通过如下任何一个命令行

    新葡亰496net 9

    2. 临时对象在创建后没有执行影响临时表的数据定义语言DDL操作(如创建索引和创建统计)

    22. JVM清理垃圾命令

    GC.run

        SET GLOBAL event_scheduler = ON;  
        SET @@global.event_scheduler = ON;  
        SET GLOBAL event_scheduler = 1;  
        SET @@global.event_scheduler = 1;  
    

     

    1. 没有使用动态SQL创建临时对象

    23. 循环队列引入的目的

    消除线性队列的“假溢出”,充分利用存储空间。

     

    存储过程中显式删除临时表,到底有没有用处?

    4. 临时对象被创建在另一个对象的内部,如存储过程、触发器、用户自定义函数或临时对象是一个用户自定义表值函数的分会表

    24. Webservice是什么?它的引擎是什么?

    WebService是一个平台独立的、低耦合的,自包含的、基于可编程的web应用程序,可使用开放的xml标准来描述、发现、发布、协调和配置这些应用程序,是用户开发互操作的分布式系统。最基本的目的就是提供在各个不同平台的不同应用系统的系统工作能力。

            通过配置文件my.cnf

    对上面的存储过程做如下修改,在存储过程结束之前显式删除定义的临时表

     --=====================================================================

    25. Tomcat集群中怎么实现共享

    1:Tomcat的Session复制。在一台Tomcat的Session发生变化时,将变更的数据分发给其它的Tomcat服务器。

    2: 采用 memcached session manager 共享session。

    event_scheduler = 1 #或者ON  
    

    新葡亰496net 10

     依旧妹子引狼(最近小忙,不能保证妹子质量,勿怪)

    26. Git和Svn有什么区别?

    1:git是分布式的版本控制系统,SVN不是。GIT和SVN都有自己的集中式版本库或服务器,但是GIT更倾向分布式使用。

    2:GIT把内容按数据方式存储,而SVN是按文件存储的。

    3:GIT可以很容易的发现未被合并的分支,SVN需要手动运行命令来确定代码是否被合并。

    4:GIT没有一个全局的版本号,SVN有。但GIT内容完整性要优于SVN。

    5:GIT在下载后即使在不联网状态也可以看到所有数据,但SVN必须要联网。

    6:GIT的提交速度优于SVN,且GIT可以有无限个版本库,但SVN只有一个中央数据库,一旦这个中央库有问题,则所有代码都会全部瘫痪。

    7:管理一个GIT库相对于管理一个SVN库更容易。

     

      然后再次执行如下的测试代码,注意截图是第二次执行的结果(下面会做解释为什么是第二次的执行的结果)

    新葡亰496net 11

    27. dubbo服务开发流程,运行流程?zookeeper注册中心的作用?端口是多少?

    服务容器负责启动,加载,运行服务提供者。

    1. 服务提供者在启动时,向注册中心(默认端口2181)注册自己提供的服务。

    2. 服务消费者在启动时,向注册中心订阅自己所需的服务。

    3. 注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。

    4. 服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。

    5. 服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。

            查看调度器线程

    新葡亰496net 12

     

    28. redis为什么可以做缓存?redis都是怎么用的?都用来存什么了?redis的存储结构?Redis集群搭建?redis的事务;redis丢失问题

    使用redis做缓存的原因

    redis是用C语言编写的,稳定性和性能更好。支持集群模式和持久化等特性,不会应为缓存量太多而导致虚拟机崩溃。Redis是独立部署的,即使网站更新,redis缓存的数据也不会消失。

    集群搭建(redis需要3台主机,3台从机,则配置6台,需要6个端口):

    1:安装ruby环境,上传接口工程,安装接口程序,拷贝脚本到指定位置

    2:创建6个redis实例,修改配置文件 ,然后启动所有redis实例(为简化启动步骤,可编写启动脚本)。

    3:执行创建集群的命令,连接测试

        mysql> show processlist;  
         ---- ----------------- ----------- ------ --------- ------ ------------------------ ------------------   
        | Id | User            | Host      | db   | Command | Time | State                  | Info             |  
         ---- ----------------- ----------- ------ --------- ------ ------------------------ ------------------   
        |  2 | root            | localhost | NULL | Query   |    0 | NULL                   | show processlist |  
        |  3 | event_scheduler | localhost | NULL | Daemon  |    6 | Waiting on empty queue | NULL             |  
         ---- ----------------- ----------- ------ --------- ------ ------------------------ ------------------   
    

      然后继续在临时库的系统表中查询上述Id的系统,发现临时表依旧存在于系统表中,即便是存储过程中显式删除(drop table #t20170413)

     

    redis的事务

    Redis的事务是一组命令的集合,Redis事务的实现需要用到 MULTI 和 EXEC 两个命令,事务开始的时候先向Redis服务器发送 MULTI 命令,然后依次发送需要在本次事务中处理的命令,最后再发送 EXEC 命令表示事务命令结束。

     

    新葡亰496net 13

     

    redis丢失问题常见原因:

    程序bug或人为误操作
    · 因客户端缓冲区内存使用过大,导致大量键被LRU淘汰
    · 主库故障后自动重启,可能导致数据丢失
    · 网络分区的问题,可能导致短时间的写入数据丢失
    · 主从复制数据不一致,发生故障切换后,出现数据丢失
    · 大量过期键,同时被淘汰清理

            3.2.3 关闭事件调度器

      这里说明,即便在存储过程中显式调用了删除临时表的操作,临时表依旧会存在得临时库的系统表中,也就是说临时表依旧会被缓存。
      并不会因为在存储过程中显式删除而真正的删除,临时表对象会缓存在临时库的系统表中。
      之所以Session中查询到的临时表的名字与系统表中查询到的临时表的名字不同,
      原因是临时表从创建到缓存(当前Session断开之后),在内部只是发生了一个对当前Session临时表重命名的过程。
      被缓存的临时表的重用的过程与上面的类似,也是将缓存的换反向重命名。

    29. 消息中间件acitveMQ的作用、原理?

    作用:acitveMQ就是消息队列,activemq安装之后,会有一个broker(经纪人)。

    消息的生产者将消息发送到broker中,它不关心谁消费该消息。

    消息的消费者去broker中获取信息,它不关心谁提供消息

            通过命令行

    事实证明:
    对于存储过程的临时表,在满足可缓存的前提下(只是表结构,当然不包括临时表的数据),
    你删,或者不删,他都会缓存在临时库中,并不因为显式Drop临时表,临时表就会被真正的删除,这是SQL Server专门为此做的优化,你真的不用为删除临时表而操心或者纠结
    这里回到一开始的问题,存储过程中有没有必要显式删除临时表就有答案了:对于存储过程的创建的临时表,没必要删除,对于满足可缓存的临时表对象,想删也删不掉!

    30. AJAX的怎样实现同步或者怎样实现异步?

    $.ajax({
        async:false // 为false 时 为同步, 默认 为true , 为异步
    })

            可通过如下任何一个命令行

     

    31. fastDFS分布式文件系统

    fastDFS有两个角色:跟踪器(tracker)和存储节点(storage);

    存储数据:

    跟踪器负责记录图片地址,和响应java接口访问。java接口要想储存图片地址需向跟踪器发送请求,然后由跟踪器查找图片仓库地址发给java接口,同时记录储存过程,

    Java接口配IP是配2个的,因为有2个跟踪器,而java接口连接IP时并不是智能的,如果连接第一个跟踪器没反应(第一个没反应不是忙就是挂了),它就会连接第二个跟踪器,不管连哪个跟踪器,最终都会返回一个地址给java接口。而两个跟踪器之间是有通信的,它们会把信息同步的,这个信息也就是meta信息,也就是管理的帐本。

    跟踪器和存储节点有通信间隔时间,这个时间由我们决定。而存储节点之间也是有通信的,如果有一天存储节点和存储节点的仓库都满了,就扩张仓库,创建下一组存储节点和存储仓库。

    取数据:

    取数据的时候可以用java接口取,也可以用页面里的<img src=”http//…..jpg/>”取,但是src属性会在页面加载后发出2次请求。Src会根据地址去找跟踪器,而跟踪器会告诉它这地址图片在哪个存储节点身上,跟踪器这台机器上搭建是nginx服务器(反向代理服务器)这个服务器是用来解决高并发用的。Nginx服务器会根据你的路径找到存储节点身上的图片。然后再将存储节点的图片拿回来,再加载给src,到img标签里。

    启动:

    先设置IP再修改IP,然后三个命令分别启动跟踪器,存储节点,Nginx服务器

        SET GLOBAL event_scheduler = OFF;  
        SET @@global.event_scheduler = OFF;  
        SET GLOBAL event_scheduler = 0;  
        SET @@global.event_scheduler = 0;  
    

    存储过程中定义的临时表,只有满足一定的条件,才会被缓存重用

    32. Maven-热部署

    热部署:就是maven管理的项目发布到测试服务器,省去以往发布时要不停的启动、关闭tomcat这些繁琐 的过程;热:就是tomcat一直保持开启状态,

    1、设置tomcat用户名和密码,然后启动tomcat

    2、在你所要发布的项目里的pom.xml里设置你要发布项目的路径同时把tomcat用户名和密码也设置上

    3、发送发布命tomcat7:deploy

    4、强硬发布命令:tomcat7:redeploy

     

      上面说了,临时表的重用是要满足一定条件的,如下条件将会导致临时表无法重用

    33. Log4j的输出级别都有哪些

    DEBUG Level: 指出细粒度信息事件对调试应用程序是非常有帮助的,就是输出debug的信息.
    INFO level: 表明消息在粗粒度级别上突出强调应用程序的运行过程,就是输出提示信息.
    WARN level: 表明会出现潜在错误的情形,就是显示警告信息.
    ERROR level: 指出虽然发生错误事件,但仍然不影响系统的继续运行.就是显示错误信息.
    FATAL level: 指出每个严重的错误事件将会导致应用程序的退出.
    ALL level: 是最低等级的,用于打开所有日志记录.
    OFF level: 是最高等级的,用于关闭所有日志记录.

            通过配置文件my.cnf

    1,创建临时表的时候存在命名约束(这一点非常操蛋,不仅仅是缓存问题,曾经遇到过坑,有机会演示)
    2,在临时表创建之后执行DDL操作,比如创建索引等,但是这个DDL不包括drop 临时表和truncate临时表
    3,动态SQL方式创建的临时表
    4,在不同的范围之内创建的临时表,应该是存储过程调用另外一个存储过程,另外一个存储过程定义的临时表,这一点还没有具体研究
    5,存储过程以WITH RECOMPILE重编译的方式运行

    34. zookeeper存在什么缺陷

    本身不是为高可用性设计,撑不住高流量容易导致系统崩溃。还有对网络隔离的敏感也导致Zookeeper的脆弱

            在[mysqld]下增加

      比如在上面的存储过程,在临时表定义之后,创建一个索引,
      此举将会造成临时表无法重用,这种情况下,不管你删或者不删,存储过程执行完成Session断开之后,临时表都不会缓存(在临时库中)
      这一点就不截图演示了,有兴趣的自己测试

    35. 开启多线程的三种方式

    1) 继承thread类  重新run函数  对象。start开启

    2) 实现runnnable接口  重写run函数

    3) 实现callable

    event_scheduler = 0 #或者OFF,DISABLED  
    

    新葡亰496net 14

    36. 接口collection和抽象类abstrator class 的区别

    1)接口是公开的,不能有私有方法和变量,但是抽象类可以

    2)实现一个接口必须实现接口的方法,抽象类可以重写也可以不重写

    3)接口可以实现多重继承,抽象类只能实现多个接口

     

     

    37. override和overload的区别

    重写是指子类继承父类,重写父类的方法。重载是多态的一种表现形式,是指在同一类中方法名相同参数列表不同的同命名方法。

             查看调度器线程

      解释另外一个问题:
      既然认为无法删除缓存的临时表,正常情况下,缓存的临时表什么情况下会被删除?
      上面说截图都是第二次运行的截图,因为在存储过程重建之后(create或者alter),这个存储过程中定义的临时表都会被清理掉
      只有重建了存储过程,第一次执行之后,缓存的临时表在第二次执行的时候才能被重用
      当然这一点也和容易验证,缓存临时表之后,然后alter 存储过程,
      然后根据缓存临时表的Id去查询临时库中sys .tables的信息,这个缓存的表会在1~2秒之后被删除(个人测试验证过)
      另外显式执行DBCC FREEPROCCACHE,也能删除缓存的临时表。
      其实也不难理解,缓存的对象是跟执行计划缓存绑定的,如果执行计划本身就不存在了,那么缓存的临时表对象也将会被请处理。

    38. 匿名内部类

    匿名内部类也就是没有名字的内部类

    正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写

    但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口

    mysql> show processlist;  
     ---- ------ ----------- ------ --------- ------ ------- ------------------   
    | Id | User | Host      | db   | Command | Time | State | Info             |  
     ---- ------ ----------- ------ --------- ------ ------- ------------------   
    |  2 | root | localhost | NULL | Query   |    0 | NULL  | show processlist |  
     ---- ------ ----------- ------ --------- ------ ------- ------------------  
    

     

    框架部分

     

    并发执行的情况下,临时表能否重用?

    1. SpringMVC接收参数的方式

    1:通过@PathVariable获取路径中传递的参数 在方法参数前

    2:通过@ModelAttribute获取post请求中的form表单数据 在方法参数前

    3:通过HttpServletRequest获取

    3:用@RequestParam

     

      并发线程之间当然不会重用同一个临时表,如果不是这样的话,SQL Server也不用混江湖了,并发的每个线程会创建自己的临时表。
      参考如下截图是在并发情况下,tempdb产生的临时表的情况,每个线程调用存储过程产生的临时表后缀都是不一样的。
      并发调用存储过程的时候,每个线程会产生属于自己的临时表,重用临时表是发生在当前线程执行完成之后,其他Session重新调用存储过程时候才能重用已缓存的临时表。
      鉴于本文不是专门说明临时表的,这里就不多说了。

    2. SpringMVC配置文件

    Web.xml:初始化spring容器 加载配置文件 contextConfigLocation

    配置前端控制器 加载SpringMVC.Xml 设定startup为1,启动时加载 过滤所有请求

    统一编码方式 CharacterEncodingFilter 过滤所有请求

    Spring.xml:配置包扫描器 context:component-scan

    配置注解驱动 mvc:annotation-driven

    配置视图解析器 InternalResourceViewResolver <bean>

    加载静态资源 mvc:resources

    配置多部件解析器 CommonsMultipartResolver 设定默认编码和文件上传的最大值

    加载Java的其余配置文件 context:property-placeholder

        3.3 例如:创建一个表记录每次事件调度的名字和事件戳

      新葡亰496net 15

    3. ssm和ssh的区别或者优势

    SSH通常指Struts2做控制器,Spring管理各种组件,Hibernate负责持久化层。

    SSM通常指SpringMVC做控制器,Spring管理各层组件,Mybatis负责持久化层。

    相同点:1:Spring依赖注入来管理各层组件

    2:使用面向切面的AOP编程思想管理事务、日志、权限等。

    不同点:Struts2和SpringMVC控制器控制视图和交互机制不同。

        3.3.1 创建测试表

     

    4. Struts2和SpringMVC的区别

    1:SpringMVC开发效率高于Struts2,且SpringMVC以基本实现0配置。

    2:SpringMVC实现依赖Servlet,是单例的,参数基于方法进行封装。

    3:SpringMVC是方法级别的拦截,一个方法对应一个request上下文,方法对应URL。方法之间的变量是不共享的,方法是独立的,可以使用注解方式接收参数。

    4:Struts2是类级别的拦截,一个类对应一个request的上下文,配置文件较复杂,架构比较费时费力。虽然每个方法之间也是独立的,但所有类变量都是共享的,虽然不影响运行,但是编码、读程序却比较麻烦。

    5:Struts2实现依赖过滤器,是多例的,参数是基于属性进行封装。

    6:Struts2需要封装每一个Request,把每个生命周期变量封装成一个个的MAP集合,并要保证线程的安全,比较耗费内存。

        mysql> drop table if exists events_list;  
        mysql> create table events_list(event_name varchar(20) not null, event_started timestamp not null);  
    

    显式删除临时表与否的性能测试

    5. Hibernate和MYbatis的区别

    相同点:Hibernate和Mybatis都是通过SessionFactoryBuider由xml文件生成SessionFactory,然后生成Session,由Session开启执行事务和SQL语句。其中SessionFactoryBuider,SessionFactory,Session的生命周期都是差不多的。都支持JDBC和JTA事务处理。

    不同点:

    Mybatis:Mybatis可以进行更为细致的SQL优化,可以减少查询字段。

    Mybatis相对于Hibernate更容易掌握,门栏较低。

    Hibernate:Hibernate的DAO层开发比Mybatis更简单,因为Mybatis需要维 护SQL和映射结果。

      Hibernate对对象的维护和缓存要比MyBatis好,对增删改查的对象的维护要方便。

      Hibernate数据库移植性很好,MyBatis的数据库移植性不好,不同的数据库需要写不同SQL。

      Hibernate有更好的二级缓存机制,可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

     

    既然上面说了,如果存储过程中定义的临时表满足临时表被缓存的条件的情况下,存储过程中是否删除临时表,临时表都一样会被缓存
    那么,如果真的指定了显式删除临时表操作,与没有显式指定删除临时表,性能上有没有差别呢?
    抱着以数据说话的态度,分别在存储过程中不删除与显式删除临时表,用SQLQueryStress做了一系列的性能测试
    结果如下

    6. Hibernate的一级缓存和二级缓存

    Hibernate的一级缓存指的是Session缓存,因为Session缓存是内置的,是Hibernate的默认配置;二级缓存指的是SessionFactory的外置缓存,因为外置缓存是数据库数据的拷贝,介质可以是内存或硬盘,需要手动开启。

        3.3.2 创建事件1(立即启动事件)

    不显式删除临时表 显式删除临时表

    7. spring的事务管理

    Spring的事务管理分为声明式和编程式。声明式事务可以使用tx标签方式、使用代理方式以及拦截器方式。编程式事务需要在配置中配置Session工厂,配置事务管理器,开启注解扫描,使用@Service

        create event event_now   
        on schedule   
        at now()   
        do insert into events_list values('event_now', now());  
    

    测试结果如下, 

    8. springmvc的注解都有哪些

    @Controller  @requestMapping @PathVariable @[email protected] @ResponseBody @RestController @ModelAttribute

     

      新葡亰496net 16

    9. hibernate的优化

    1:数据库设计时要降低关联的复杂性,尽量不使用联合主键,适用冗余数据,不过分追求高范式

    2:使用延迟加载

        查看事件执行结果

      测试过程部分截图(不浪费博客园的图片服务器资源了,随便截了两张)

    10. hibernate的五个核心类

    Configuration,sessionfactory,Session,query接口,transaction接口

        mysql> select * from events_list;  
         ------------ ---------------------   
        | event_name | event_started       |  
         ------------ ---------------------   
        | event_now  | 2014-07-01 04:06:40 |  
         ------------ ---------------------   
    

      新葡亰496net 17新葡亰496net 18

    11. Spring的优点: 缺点

    优点:

    方便解耦,简化开发---Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理

    AOP编程的支持---Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能

    声明式事务的支持---只需要通过配置就可以完成对事务的管理,而无需手动编程

    方便程序的测试---Spring对Junit4支持,可以通过注解方便的测试Spring程序

    方便集成各种优秀框架---Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持

    降低JavaEE API的使用难度---Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

     

    缺点:

    jsp中要写很多代码、控制器过于灵活,缺少一个公用控制器

     

      从测试结果看,确实有一些差异,不过这个差别是非常小的,
      第一组测试结果5000次调用产生了0.07秒的差距
      第二组测试结果20000次调用产生了0.35秒的差距,平均到一次差距也就在微妙级,即便是显式调用删除,对性能来说是有一点点影响,不过这个影响也是无伤大雅。
      不过这个内部的原始一定要弄清楚,有没有必要删除,以及原因,这个才是原则性的问题!

    12. spring工作机制和为什么要用

    工作机制:Spring的核心就是IOC和AOP所以Spring的工作机制简单的理解也就是IOC和AOP的工作机制。

     原因:借助于Spring AOP,Spring IOC能够很方便的使用到非常健壮、灵活的企业级服务,通过使用IoC能够降低组件之间的耦合度,最终,能够提高类的重用性,利于测试,而且更利于整个产品或系统集成和配置

        3.3.3 创建事件2(每分钟启动事件)

        至于临时表数据占用的空间,也不是说显式删除就释放,不删除就不释放,应该是有后台进程来做这个工作的,个人建议不用为这个问题瞎操心。
      写存储过程的时候,多写一点好一点的SQL语句,比纠结这个强多了。

    13. AOP和IOC概念和在spring中如何应用

    Springmvc是spring一部分

    IOC:控制反转,生产对象用。控制权由应用代码中转到了外部容器,控制权的转移,是所谓的反转。

    AOP:面向切面编程,底层使用动态代理,作用:管理事务和安全监控,事务 只需要配置一次就不用再配置。

        create event test.event_minute   
        on schedule   
        every  1 minute    
        do insert into events_list values('event_now', now());  
    

    多啰嗦一句:
    有些人的观念是根深蒂固的,对于习惯删除临时表的人,觉得这么做“规范”,“专业”,虽然他没有确切的理由说明显式删除临时表的必要性。
    但是你要跟他说没必要删除临时表,一定会激怒他,好多程序员都是这样的,你否认他根深蒂固的一个观点的时候,他是很恼火的。
    从生物学上说,这个是属于“印随行为”,如宗教般,在自己处于懵懂期的时候,受到一些说法的影响
    或许是当初的师傅说的,或者膜拜的对象这么做了,或者听高人说过这么做比较好,然后自己就一直这么做了并且坚信不疑。
    当然,包括我自己在某些时候也有此种行为,思维被曾经的某一些经历固化,然后一直束缚自己的认知。
    不过对于无伤大雅的问题,就随他去了,没必要说服他,弄不好他反过来觉得你业余,希望小伙伴们明辨,好似乎跑题了……

    14. MVC设计思想

    Mvc是一个架构设计思想:

    用户发送请求至控制器(Controller),控制层把用户请求转发给模型Model层进行数据处理,Model层内包含javabean组件、领域模型、业务层、持久层,Model层处理完数据层响应给控制层,控制层再次把数据发送给视图View进行视图编译,然后由View层把视图页面返回给控制层,控制层再响应给用户。

     

     

    15. Springmvc框架原理

    • 用户发送请求给前端控制器DisPatcherserlvlet:前端控制器只负责接受请求,转发请求,响应结果数据。DispatcherServlet就是一个中央控制器。
    • 前端控制器需要委托处理器映射器去寻找获取Handler(Controller)
    • 处理器映射器根据浏览器请求去寻找指定属性的Controller
    • 返回执行Chain(链),链中具有很多拦截器 ,Handler(Controller)在拦截器中间被返回给前端控制器。
    • 前端控制器拿到Controller以后需要去执行Controller,交给处理器适配器去执行
    • 处理器适配器负责调用Controller里面的方法,进行执行Controller
    • Controller返回一个模型视图(ModelAndView)
    • 处理器适配器把这个ModelandVIew交给前端控制器
    • 前端控制器把模型视图ModelAndView给视图解析器(viewResolver)解析出物理视图

    返回给前端控制器

    • 渲染视图:el jsp el表达把model数据解析封装到jsp页面的过程就叫渲染视图
    • 返回用户

        查看事件执行结果

    显式删除临时表与否与临时库空间释放问题

    16. POJO概念

    POJO是mybatis中的返回值的参数类型,它和bean一样意思。Bean是指类,而POJO把类看成对象。Mybatis是在JDBC上做的封装,为了使SQL语句不再是硬编码和不用再按顺序执行,为了在框架里获取sql语句而设定的一种概念,得到的是动态SQL。

        mysql> select * from events_list;  
         ------------ ---------------------   
        | event_name | event_started       |  
         ------------ ---------------------   
        | event_now  | 2014-07-01 04:26:53 |  
        | event_now  | 2014-07-01 04:27:53 |  
        | event_now  | 2014-07-01 04:28:53 |  
         ------------ ---------------------   
    

      有人担心说,如果不显式删除临时表,是不是临时表占用的空间无法快速释放?
      其实也不用顾虑,还是以数据说话,这里对比两个一样的存储过程,一个不显式删除临时表,一个显示删除临时表,看看临时数据库中用户对象占用page的情况
      不显式删除临时表的存储过程
      做如下对比测试,借助SQLQueryStress,做一个20线程,每个线程500次循环的测试

    17. Freemaker页面静态化怎么实现的,商品下架怎么删除,静态化页面可以发送异步请求吗?Freemaker放在那里,如何访问

    实现过程:

    在商品添加服务中发送商品ID消息,接收消息中的商品ID。

    从spring上下文中获取Freemarker的配置文件(configuration)对象。

    通过configuration创建模板(template对象),模板的名称在java配置文件中配置。

    创建模板数据:根据商品ID查询出商品信息,如果没有数据,抛出异常。

    指定输出文本。文本的路径在java配置文件中配置,文本的名称是商品ID,文本的后缀在java配置文件中配置。

    调用template的process方法,生成输出文件。

     

    可以发送异步请求,使用Nginx访问

     

          新葡亰496net 19

    18. Hibernate对象的三种形态

    临时状态(transient):刚用new语句创建,还没有被持久化,不处于Session的缓存中。处于临时状态的Java对象称为临时对象。

    持久化状态(persistent):已经被持久化,加入到Session的缓存中。处于持久化状态的Java对象称为持久化对象。

    游离状态(detached):已经被持久化,但不再处于Session的缓存中。处于游离状态的Java对象称为游离对象。

    Java对象:开始生命周期——》临时状态——》持久化状态——》游离状态——》结束生命周期

    3.3.3 创建事件3(每秒钟启动事件)

      测试的过程中,在临时数据库中,利用如下SQL,间隔一秒的频率抓取临时库中user objects对象的数据

    19. servlet的生命周期

     1,实例化阶段  调用init()方法

     2,服务阶段  调用service()方法

     3,销毁阶段  调用destroy()方法

    首先客户发送一个请求,Servlet是调用service()方法对请求进行响应,通过源代码可见,service()方法中对请求的方式进行了匹配,选择调用doGet,doPost等这些方法,然后再进入对应的方法中调用逻辑层的方法,实现对客户的响应。在Servlet接口和GenericServlet中是没有doGet,doPost等等这些方法的,HttpServlet中定义了方法,但是都是返回error信息,所以,我们每次定义一个Servlet的时候,都必须实现doPost,doGet等这些方法。

        CREATE event event_now   
        ON SCHEDULE   
        EVERY 1 SECOND 
        DO INSERT INTO event_test VALUES(1);  
    

      新葡亰496net 20

    20. ORM

    对象关系映射,也就是一种程序技术,用于实现面向对象编程语言里不同类型系统的数据之间的转换 。从效果上说,它其实是创建了一个可在编程语言里使用的--“虚拟对象数据库”。

     

      把上述脚本记录到的数据,利用Excel的透视图功能,呈现出来上述脚本记录到的user objects数量,可以很清楚地发现,不显式删除临时表,与显式删除临时表相比,UserObjecs数量并没有明显的差异
      也就数说,不显式删除临时表的情况下,并没有出现临时表空间对象释放不及时的情况

    21. JVM

    JVM是java的核心和基础,在java编译器和os平台之间的虚拟处理器。它是一种基于下层的操作系统和硬件平台并利用软件方法来实现的抽象的计算机,可以在上面执行java的字节码程序。java编译器只需面向JVM,生成JVM能理解的代码或字节码文件。Java源文件经编译器,编译成字节码程序,通过JVM将每一条指令翻译成不同平台机器码,通过特定平台运行。

    JVM执行程序的过程 :

    I.加载.class文件

    II.管理并分配内存

    III.执行垃圾收集

    3.3.4 创建事件4(每秒钟调用存储过程) 

      新葡亰496net 21

    22. JDBC

    JDBC(java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序,同时,JDBC也是个商标名。

    CREATE DEFINER=`root`@`localhost` EVENT `eventUpdateStatus` ON SCHEDULE EVERY 1 SECOND STARTS '2017-11-21 00:12:44' ON COMPLETION PRESERVE ENABLE DO call updateStatus()
    

       因此大可不必担心,不显式删除临时表,临时表申请的空间无法及时释放。

    23. Struts2框架工作流程及原理

    1、客户端浏览器发出HTTP请求.

    2、根据web.xml配置,该请求被FilterDispatcher接收

    3、根据struts.xml配置,找到需要调用的Action类和方法, 并通过IoC方式,将值注入给Aciton

    4、Action调用业务逻辑组件处理业务逻辑,这一步包含表单验证。

    5、Action执行完毕,根据struts.xml中的配置找到对应的返回结果result,并跳转到相应页面

    6、返回HTTP响应到客户端浏览器

    原理:

    1 客户端初始化一个指向Servlet容器(例如Tomcat)的请求 
    2 这个请求经过一系列的过滤器(Filter)(这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器,这个过滤器对于Struts2和其他框架的集成很有帮助,例如:SiteMesh Plugin) 
    3 接着FilterDispatcher被调用,FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action 
    4 如果ActionMapper决定需要调用某个Action,FilterDispatcher把请求的处理交给ActionProxy 
    5 ActionProxy通过Configuration Manager询问框架的配置文件,找到需要调用的Action类 
    6 ActionProxy创建一个ActionInvocation的实例。 
    7 ActionInvocation实例使用命名模式来调用,在调用Action的过程前后,涉及到相关拦截器(Intercepter)的调用。 
    8 一旦Action执行完毕,ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是(但不总是,也可 能是另外的一个Action链)一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper 

     

      

    数据库部分

     

    总结:   

    1. 数据库优化问题

    1:表的设计要符合三范式。

    2:添加适当存储过程,触发器,事务等。

    3:添加适当的索引,索引对查询速度影响很大,必须添加索引。主键索引,唯一索引,普通索引,全文索引

    4:读写分离(主从数据库,主数据库进行写的操作,从数据库惊醒读的操作,主数据库将数据更新到从数据库)

    5:对sql语句的一些优化,(查询执行速度比较慢的sql语句)

    a:查询中避免使用通配符,尽量使用索引。选择联合查询的联合次序

    b:在子查询中避免使用in 或 not in 语句,使用where (NOT) exists的效果要好的多;避免使用BY RAND随机显示结果。

    c:使用联合(UNION)代替手动创建的临时表,拆分表格。

    d:尽可能的使用NOT NULL(非空),对MySQL的配置进行优化

    6:分表分区

    分表:把一张大表分成多张表。分区:把一张表里面的分配到不同的区域存储,

    对mysql服务器硬件的升级操作。

     

      本文从存储过程中的临时表是否需要显式删除入手,简单介绍了临时表重用的现象和前提条件,以及有无必要显式删除临时表,
      同时测试了临时表在满足重用的情况下,临时表显式删除与否的性能问题,对于存储过程中定义的临时表,不管是否能否缓存重用,都不建议显式删除。

    2. 如果数据库里边的大表添加字段  怎么弄效率最高

    alter table ~ add  ~  添加列

        3.4 注意:

     

    3. mysql默认的最大连接数是多少?

    mysql的最大连接数默认是100, 最大可以达到16384

        默认创建事件存储在当前库中,也可显示指定事件创建在哪个库中

    参考链接:
         

    4. mysql分页;limit关键字

    limit关键字:LIMIT 可以被用于强制 SELECT 语句返回指定的记录数。LIMIT 接受一个或两个数字参数。参数必须是一个整数常量。如果给定两个参数,第一个参数指定第一个返回记录行的偏移量,第二个参数指定返回记录行的最大数目。初始记录行的偏移量是 0(而不是 1)

        通过show events只能查看当前库中创建的事件

          

    5. 创建索引库的优缺点?

    优点:通过创建唯一性索引,可以保证数据库中每一行数据的唯一性,2,可以大大加快数据的检索速度,这也是创建索引的最主要的原因,3.可以加速表与表之间的连接,特别是在实现数据的参考完整性。

    缺点:创建索引和维护索引需要消耗时间,这种时间随着数据的增加而增加,2.索引占用物理空间,需要的空间变大,3.当对数据库中的数据进行增删改的时候,索引也需要动态的维护,此时降低了维护速度。

        事件执行完即释放,如立即执行事件,执行完后,事件便自动删除,多次调用事件或等待执行事件可以查看到。

    6. 集合去重,数据库去重;(集合去重有contains方法;数据库去重用group by)

    集合去重:

    a:转化为Set集合,因为HashSet集合不允许重复值存在。

    b:使用双重循环删除重复的值或者用null代替

    c:用contains方法

    数据库去重:

    a:使用嵌套的查询 得到所有的不重复数据的Id,使用 not in 关键字删除所有ID不在以上范围中的数据。

    b:使用嵌套的查询 得到所有的不重复数据的Id,将所有数据存储到一个临时表中,删除原表,重新构建原表,将临时表数据导入原表,删除临时表

        如果两个事件需要在同一时刻调用,mysql会确定调用他们的顺序,如果要指定顺序,需要确保一个事件至少在另一个事件1秒后执行

    7. 怎样建立索引?

    普通索引:添加index

    Alter table user add index_name(name),括号内为字段名称

    主键索引

    Alert table user add primary key(id)

    唯一索引:添加unique

    Alert table user add unique (creattime)

    全文索引:添加fulltext

    Alert table user add fulltext(name)

        对于递归调度的事件,结束日期不能在开始日期之前。

    8. mysql存储过程

    Mysql存储过程就是为完成特定功能的SQL语句集,经过编译之后存储在数据库中,当需要使用该组SQL语句时,用户只需要通过指定存储过程的名字并给定参数就可以调用。

    存储过程是一个可编程的函数,在数据库中创建并保存。可以有SQL语句和一些特殊的控制结构组成。可以看做是对编程中面向对象的模拟。

        select可以包含在一个事件中,然而他的结果消失了,就好像没执行过。

    9. MySQL与Oracle的区别

    1.  Oracle是大型数据库而Mysql是中小型数据库,Oracle市场占有率达40%,Mysql只有20%左右,同时Mysql是开源免费的而Oracle价格非常高。

    1. Oracle支持大并发,大访问量,是OLTP最好的工具。

    3. 安装所用的空间差别也是很大的,Mysql安装完后才152M而Oracle有3G左右,且使用的时候Oracle占用特别大的内存空间和其他机器性能。

    4.Oracle也Mysql操作上的一些区别

    ①主键 Mysql一般使用自动增长类型,在创建表时只要指定表的主键为auto increment,插入记录时,不需要再指定该记录的主键值,Mysql将自动增长;Oracle没有自动增长类型,主键一般使用的序列,插入记录时将序列号的下一个值付给该字段即可;只是ORM框架是只要是native主键生成策略即可。

    ②单引号的处理 MYSQL里可以用双引号包起字符串,ORACLE里只可以用单引号包起字符串。在插入和修改字符串前必须做单引号的替换:把所有出现的一个单引号替换成两个单引号。

    ③翻页的SQL语句的处理 MYSQL处理翻页的SQL语句比较简单,用LIMIT 开始位置, 记录个数;ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个ROWNUM字段标明它的位置, 并且只能用ROWNUM<100, 不能用ROWNUM>80

    ④ 长字符串的处理 长字符串的处理ORACLE也有它特殊的地方。INSERT和UPDATE时最大可操作的字符串长度小于等于4000个单字节, 如果要插入更长的字符串, 请考虑字段用CLOB类型,方法借用ORACLE里自带的DBMS_LOB程序包。插入修改记录前一定要做进行非空和长度判断,不能为空的字段值和超出长度字段值都应该提出警告,返回上次操作。 ⑤空字符的处理 MYSQL的非空字段也有空的内容,ORACLE里定义了非空字段就不容许有空的内容。按MYSQL的NOT NULL来定义ORACLE表结构, 导数据的时候会产生错误。因此导数据时要对空字符进行判断,如果为NULL或空字符,需要把它改成一个空格的字符串。

    ⑥字符串的模糊比较 MYSQL里用 字段名 like '%字符串%',ORACLE里也可以用 字段名 like '%字符串%' 但这种方法不能使用索引, 速度不快。

     

    ⑦Oracle实现了ANSII SQL中大部分功能,如,事务的隔离级别、传播特性等而Mysql在这方面还是比较的若

     

    基础部分 1. 线程和进程的区别 线程三个基本状态:就绪、执行、阻塞 线程五个基本操作:创建、就绪、运行、...

    4 查看事件

        查看当前所在库的事件

    mysql> show events; 
    

     

        查看所有事件

     

    mysql> select * from mysql.event;  
    

     

    5 修改事件

        一条alter event语句可以修改事件的定义和属性。我们可以让一个事件成为停止的或者再次让它活动,也可以修改一个事件的名字或者整个调度。然而当一个使用 ON COMPLETION NOT PRESERVE 属性定义的事件最后一次执行后,事件直接就不存在了,不能修改。

        5.1 语法如下:

        ALTER  
            [DEFINER = { user | CURRENT_USER }]  
            EVENT event_name  
            [ON SCHEDULE schedule]  
            [ON COMPLETION [NOT] PRESERVE]  
            [RENAME TO new_event_name]  
            [ENABLE | DISABLE | DISABLE ON SLAVE]  
            [COMMENT 'comment']  
            [DO event_body]  
    

     

        5.2 例如

        修改上面例子3.3.3 每分钟启动事件为每30秒启动

     

        alter event test.event_minute  
        on schedule   
        every  30 second    
        do insert into events_list values('event_now', now());  
    

     

     

     

        修改上面例子3.3.3 事件名字为event_second

     

    alter event test.event_minute   
    rename to test.event_second; 
    

     

        修改上面例子3.3.3 事件为不活动和再次活动

        alter event test.event_second disable;  
        alter event test.event_second enable;  
    

     

     

    6.删除事件

        如果一个事件不再需要,我们可以使用一条drop event 语句删除它。使用这条语句我们不需要等到最后一次事件调用。

        6.1 基本语法

    DROP EVENT [IF EXISTS] event_name  
    

     

        6.2 例如

    drop event if exists event_second;  
    

     

     

     

     

    //一个周期性根据时间修改状态的例子:

    1.创建的存储过程

    /*!50003 DROP PROCEDURE IF EXISTS  `updateStatus` */;
    
    DELIMITER $$
    
    /*!50003 CREATE DEFINER=`root`@`localhost` PROCEDURE `updateStatus`()
    BEGIN
        UPDATE exam SET `status`="已结束" where  `status` != "已结束" AND  (NOW() - endTime)>0  ;
        UPDATE exam  SET `status`="正在答题"  where   `status` != "已结束" AND ( NOW() - startTime)>=0 
        AND  (NOW() - endTime)<0;
    
        UPDATE haulinfo SET bigStatus="已结束" where  bigStatus != "已结束" AND  (CURDATE() - bigEndDate)>0; 
        UPDATE haulinfo SET bigStatus="进行中" where  bigStatus != "已结束" AND  (CURDATE() - bigEndDate)<0 
        AND  (CURDATE() - bigBeginDate)>=0 ;
        UPDATE project set `status` = "完工" WHERE `status` != "完工" AND (CURDATE() - endDate)>0;
        UPDATE project set `status` = "进行中" WHERE `status` != "完工" AND (CURDATE() - endDate)<0 
        AND  (CURDATE() - startDate)>=0 ;
    END */$$
    DELIMITER ;
    

     2.创建任务调度的事件(调用存储过程)

    DELIMITER $$
    
    /*!50106 CREATE DEFINER=`root`@`localhost` EVENT `eventUpdateStatus` ON SCHEDULE EVERY 1 SECOND STARTS '2017-11-21 00:12:44' ON COMPLETION PRESERVE ENABLE DO call updateStatus() */$$
    DELIMITER ;
    

     

     /* ....  */ 在大部分语言中都一样是注释。这个之中的语句是不被执行的。

    但MYSQL中 为了保持兼容,比如从mysqldump 导出的SQL语句能被其它数据库直接使用,它把一些特有的仅在MYSQL上的语句放在 /*! ... */ 中,这样这些语句如果在其它数据库中是不会被执行,但在MYSQL中它会执行。

     

     

    例如:一个定时(每分钟)调用一个存储过程,存储过程根据进入黑名单时间推后一年删除记录,也就是从进入表开始计算一年后删除表

    blacklist表结构:

    新葡亰496net 22

     

     

    存储过程:(根据当前时间与进入黑名单时间差够一年后删除)

    delimiter //
    
    CREATE PROCEDURE clearEmploutBlack()
    
    BEGIN
    
    delete from blacklist where temporaryInStatus='0' and employeeStatus='1' and TIMESTAMPDIFF(YEAR,time,NOW())=1;
    
    END//
    
    delimiter ;
    

     

    创建事件(每分钟调用上面存储过程)

      CREATE event event_clearEmployOutBlack 
    
        ON SCHEDULE  
    
        EVERY  1 MINUTE   STARTS NOW()
    
        DO CALL clearEmploutBlack() ;
    

     

    本文由新葡亰496net发布于网络数据库,转载请注明出处:新葡亰496net:java开辟常用技艺,Server数据库的积

    关键词: