• 近来遇到有很多人想从其它开发领域转到游戏服务器开发行业上来,他们或许觉得游戏服务器开发工资高,或许觉得做游戏服务器需要掌握的技术更高级,可以锻炼自己,或许觉得想换个环境等等。不管出于什么原因吧,做为一...

    一,游戏服务器开发工作介绍

    近来遇到有很多人想从其它开发领域转到游戏服务器开发行业上来,他们或许觉得游戏服务器开发工资高,或许觉得做游戏服务器需要掌握的技术更高级,可以锻炼自己,或许觉得想换个环境等等。不管出于什么原因吧,做为一名几年的游戏服务器开发者,当然是持欢迎态度的,那么我就先介绍一下游戏服务器开发的工作吧,游戏服务器开发具体要做哪些工作呢?

    1,团队沟通

    基本上不管做什么开发,都是一个团队来完成的,游戏也是如此,游戏团队一般由老板,总经理,CTO(技术主管),主策划(领导一些人,包括数值策划,系统策划,特效策划),主美(领导一些人,包括原画,UI设计,特效动作设计),客户端主程(领导一些人,客户端程序员,客户端程序员...),服务器主程(领导一些人,包括服务器程序员,服务器程序员),外加运维。而游戏的大部分逻辑实现与逻辑数据验证都会放在服务器端,所以服务端程序需要明确了解策划的需求,要了解就需要沟通,沟通方式的正确与否,直接关系到功能的实现是否正确,由于游戏逻辑的复杂性,单纯的文档描述可能不会非常完整,不像其它行业需求文档就几百页,详细的图文并茂,制定好之后也很少变化。所以做为一名游戏程序员,一定要有良好的沟通方式和技巧。

    2,架构设计

    这个架构设计就像盖房子打基础,基础好,房子就稳固,基础不好,房子高了就容易倒。架构设计需要结合软件工程学来搞,它需要对服务器的整个流程有足够的了解,对需求的变化有足够的认识。架构的设计一般有几个特性。

    首先是易用性,架构一旦完成,在开发的时候就要方便使用,比如网络通信架构,设计好之后,其他开发者就不需要关心客户端的数据是怎么被传输到服务器端的,这个时候对于服务器开发者来说,只需要实现一些简单的接口,就可以直接对客户端发送来的请求进行处理操作。再比如说服务器端数据的存储与更新,开发者只需要写少量SQL语句或基本不用写,都由架构的底层代码完成,开发者只需要调用封装好的API,就可以把数据存入数据库而不用关心数据的最终流向,只需要关心实现逻辑就可以了。

    第二,可扩展性,可扩展性包括两个方面,一是代码的可扩展性,比如说游戏中的任务处理吧,一个游戏中任务可能有几十种,而且还可能不定时的增加,为了判断不同的任务类型该执行什么操作,最简单也是最差的写法是if else,想象一下,一个方法里面,有几十个if else,这简单是bug的理想诞生地呀。一种可行的做法是使用责任链模式(具体的请参考设计模式的实现),这样每种任务都有一个单独的类去处理它,而不会影响其它的类,符合开闭原则,相互关联少,越少越不容易出bug。二是部署的可扩展性,比如,如果在线人数突然增加或预期可能要增加,一台物理机器可能处理不过来这么多的请求,那怎么办?那就需要支持在不影响其它服务器运行的情况下,可以动态的添加机器。而当压力降低之后,又可以移除某些机器,合理利用资源。

    第三,高吞吐量,这个是指能尽量最大化的利用计算机固定的资源,去处理更多的请求,更快速的响应客户端。这就需要在服务器架构设计的时候考虑异步处理,减少IO等待时间(比如请求redis,存储数据库,和其它服务器通信)以及数据缓存。说到异步,一定会涉及到多线程,并发等相关的技术,所以架构设计的时候需要对这部分知识有足够的了解。

    第四,要考虑是否所有的功能模块都放在同一个进程中。也就是需不需要分布式开发,哪些功能需要单独拿出来。对于手机游戏来说,一般要求同时在线量比较小,功能比较单一,所有功能都在一个进程中,人数大量同时在线时,可以多部署几组进程。而对于大型网页游戏或客户端游戏来说,特别是有些大区或不分区的情况,单个功能访问量大,服务器就要考虑分布式部署开发了。

    架构设计一般需要有经验的开发者(项目主程)去搭建,新手可以做为了解,在接触到项目之后,可以按这个思路去理解项目的架构是怎么样构成的,如果让自己来做,能否模仿出来,有时间可以自己尝试去独立设计架构,锻炼自己的能力,有一天你是会实际去做的。

     

    3,逻辑开发

    架构搭建完成之后,紧接着就是游戏服务器的逻辑开发,这时才开始真正去实现游戏需要的内容,比如注册,登陆,任务,活动,背包,组队战斗等。由于游戏逻辑可能需要的判断条件多,组合变化多,所以在游戏逻辑开发过程中,你会慢慢发现面向对象的重要性。逻辑开发是一个任重而道远的过程,同一个问题,可能有很多种实现方式,不同的实现方式对效率和吞吐量有很大的影响,所以就需要对需求功能的理解要深入,不同功能之间的关联要明确。对常用的设计模式要知道如何使用。比如像上面说的替换数量比较多的if else的方式。逻辑开发需要谨慎细心,而且一定要自己测试才可以,不然bug在不知不觉中就产生了。

    4,系统周边开发

    一个游戏成功的运营,需要很多服务去支持它,比如sdk接入,充值接入,日志统计,游戏运行管理系统(一般叫后台管理系统,是内部人员为了管理游戏的而开发的系统)。比如修改某个用户的等级,封号等。管理系统一般会用web开发,与游戏服务器通信。

     

     

    二,游戏类型与技术选择

    游戏服务器开发使用的技术取决于游戏的类型,不同的游戏类型,需要的游戏环境不一样,所使用的技术也不一样。但是在本质上都是一样的,都是面对数据,处理数据,不同的是面对的数量大小而已。

    1,PC类端游

    这类游戏在线人数庞大,游戏中要处理的数据也非常庞大。所以对服务器性能要求非常高,一般都是采用C++做为开发语言,C++可以直接操作内存数据,与操作系统直接交互,减少数据之间的复制,它运行效率高,处理速度快,是这类游戏开发的首选开发语言。服务器端采用分布式架构,把不同的模块分散在多台物理机上处理。需要学习的大致有C++编程,Linux网络编程、TCP/IP通讯协议、多线程编程再加数据库。它一般开发周期比较长,一个游戏的上线基本上需要三到五年。

    2,网页游戏

    这类游戏相对于端游来说,开发周期短,因为是网页游戏,游戏的界面展示依赖于网络传输,所在在画面和特效上会次于客户端游戏很多。游戏的特点主要集中在游戏的玩法上。但是对于服务器端来说,和端游类是差不多是一样的,有些公司之前是做端游的,他们就直接把端游的服务器架构拿来就可以使用,以完成快速开发。

    3,手机游戏

    手机类游戏目前是最火最热门的游戏,因为他的用户量大,用户占有时间长。但是手机游戏大多数是一般小游戏,功能简单,玩法单一,一般都是休闲娱乐的。现在也有一些稍微大型的MORPG游戏。所以手机游戏开发周期更短,上线更快。

    目前,游戏市场竞争激烈,当前服务器主流的开发语言是C++和Java,但是C++学习难度大,开发速度慢。为了满足游戏服务器快速开发,快速上线,所以一般来说我们都是使用Java语言来开发服务器。近年来,随着游戏市场的发展,游戏服务器开发技术因Java而生成了一套体系。可以供开发者选择。

     

    三,使用Java开发服务器需要学习什么

    Java语言,由于学习成本低,开发速度快,稳定性高,开源框架多,目前已成为网页游戏和手机游戏服务器开发的主要语言。咱们从系统的开发流程简单梳理一下服务器开发需要用到的技术。

    1,网络通信

    这个是首要实现的,如果没有网络通信,就没有服务器存在的必要了。网络通信就需要建立网络连接。目前网络通信有两种方式,一种是短连接,比如http,一种是长连接,比如socket,当然http也是基于socket的,socket是通信的基础。所以要对tcp/ip通信的知识有所了解,明白通信的原理。基于这两种网络通信,游戏服务器也分为两种,弱联网和强联网。弱联网的游戏一般是指一些小型的游戏,比如开心消消乐,连连看,以及一些卡牌养成类游戏,这类游戏一般几秒钟或几分钟再会与服务器同步一次数据,一般会使用短连接。而像一些arpg游戏,实时战斗类游戏,以及带同屏显示玩家的游戏,这类游戏与服务器交互信息频繁,一秒钟可能几十次,会采用长连接,避免每次连接重新建立消耗系统资源,提高通信效率。

    为了网络通信的效率,服务器要使用NIO(非阻塞网络通信)通信。它能支持大并发连接。Java NIO是多路复用IO,在多路复用IO模型中,会有一个线程不断去轮询多个socket的状态,只有当socket真正有读写事件时,才真正调用实际的IO读写操作。因为在多路复用IO模型中,只需要使用一个线程就可以管理多个socket,系统不需要建立新的进程或者线程,也不必维护这些线程和进程,并且只有在真正有socket读写事件进行时,才会使用IO资源,所以它大大减少了资源占用。目前基于此技术有很多开源框架,最常用的有两种,Netty和Mina。

    所以在网络通信这一块,如果是弱联网游戏,可以使用web那一套来开发游戏服务器,需要学习的技术一般有http原理,Json格式协议,servlet,Tomcat(也可以是其它web容器),spring等。如果是强联网游戏,要学习的技术有Netty或Mina可以选择一种,多线程以及线程池的应用。这是网络通信所必须掌握的。只要能把客户端发送的信息接收到,并解析成代码使用的明文,就是成功了一半了,剩下的事就是把代码封装好,方便逻辑开发调用!

    通信这块还要考虑消息的并发,长连接情况下,怎么处理断包,粘包问题,每个用户的消息处理的是不是有序的,如果有序会不会阻塞消息,如果无序会不会造成处理混乱,比如后到的消息先处理了,这些问题都要处理好,目前一般是保证同一个用户的消息要有序处理!

    2,数据存储

    网络通信调试好之后,不要急着做逻辑开发,还需要把数据如何存储理清楚!因为服务器端操作的全是数据,如果处理的不好,容易出bug,丢数据,这对游戏玩家来说是致命的,不可接受的!数据存储要考虑,一,数据如何存到数据库,是同步存储,还是异步存储!同步存储即将数操作完之后立刻写入数据库,异步操作即数据操作完之后先存储到内存缓存,然后由另外的线程或进程再同步到数据库!游戏中一般都是采用的异步存储方式,因为游戏并发量大,必须低延时,快速响应客户端!如果直接操作数据库太慢,会造成消息阻塞!内存缓存可先择的框架有redis,memcache,具体怎么同步到数据库,需要自己去设计了!二,数据接口如何设计,能不能用工作生成这些数据操作的代码,能不能不用写SQL语句,需是封装在底层,或由工具生成。编程是门艺术,在这就体现出来了,当然是仁者见仁,智者见智了!三,大并发情况下数据的一致性,像这类可能多线程操作的数据,一般是放在内存中,由锁来控制并发!所以对锁的使用要熟悉,不要出现死锁,或锁粒度过大,造成线程的长时间等待的情况!四,当数据量太大,一个数据库存储不了,数据该怎么分库分表!一种是水平划分,一种是垂直划分!具体的划分方式其它资料已有详细介绍,请自行查找阅读!目前有一个开源的分库框架mycat,是用JAVA写的,大家可以研究一下!

    3,逻辑开发

    逻辑开发就是实现游戏策划想象的各种游戏功能,比如,登录,物品使用,战斗结算等!逻辑开发代码量巨大,相互之间有很紧密的耦合性,所以每个功能模块一定要划分好!最好是接触下单元测试,写之前考虑一下是否方便单元测试,这样设计的代码会更加清晰,每个方法责任明确,不容易出bug!正是因为逻辑代码复杂,为了更好的管理代码,前辈们给我们总结了一些经验,就是著名的设计模式,所以学习一下设计模式对代码的管理有很大的好处!

    逻辑开发一般遇到的问题有:

    3.1,数据同步

    一说到数据同步或资源共享的时候,一般都会考虑到锁的使用。因为一份资源同时只能被一个线程访问才是安全的。Java的JDK中提供了一些锁,比如:synchronized,以及java.util.concurrent.lock包中的Lock对象,java.util.concurrent包中还提供了其它的一些原子操作的类,我们知道i++操作不是线程安全的,但是可以使用AtomicInteger中的getAndIncrement();方法代替,还有线程安全的ConcurrentHashMap哈稀Map。以及阻塞队列LinkedBlockingQueue等。都是逻辑开发中常用的处理数据同步的类。

    3.2,设计模式的使用

    使用设计模式,可以让代码更加清晰,可扩展性更强,维护性更佳,比如,任务系统,任务会有很多种类型,要获得任务数据时,在一开始写这个系统的时候,我是这样写的if(type == 1)做什么,else if(type == 2)做什么,else if(type == 3)......else if(type == 35) else等。如果需要添加新的类型,又要添加else,这些if else都在同一个方法中。最后都不敢动一块,就怕出bug。其实当一个方法中出现三个以上的if else将来还可能增加时,就应当考虑设计是不是有问题了,后来改成责任链模式或状态模式,就解决了这个问题。还有一个例子是,当一个值变化,要影响多个任务完成状态时,可以使用观察者模式或监听模式或订阅模式去实现,这样功能之间完全解耦,出问题的机率会很小很小。

    3.3,数据缓存框架的API使用

    目前主流使用的数据缓存框架有redis和memcache,虽然在逻辑开发前,主程会对这些进行一些封装,但是作为使用者还是需要对这些框架的客户端的使用要有所了解的。这些可以去阅读相关的文档。不是太难。

    4,程序部署与运行

    目前,大多数Java项目都采用maven管理 ,可以使用maven打包开发好的程序,程序一般运行在远程服务器上,比如云服务器。一般运行Java程序的远程服务器都是Linux系统,需要使用Linux命令操作,或写一些shell脚本去自动化部署管理一些程序。

    5,艰苦奋斗的精神

    首先,一定要让自己对这一行有兴趣,明确自己在这一行的技术选择,人生选择。很多人都知道,程序员加班是常有的事,坚持的住就做,坚持不了就再换一家公司做。

     

    综上所述,想做Java游戏服务器方面的开发要掌握的技术有以下一些:

    1,网络通信框架,Mina或Netty必须熟悉一种。而且自己必须要亲自搭建过,并明白其它原理。

    2,通信协议制定和处理断包粘包,这一般属于网络通信框架要解决的问题。

    3,数据缓存框架,redis或memcache选择一个,能熟练使用其客户端的命令。

    4,Java基础,Java NIO通信原理,Java集合的使用,Java多线程开发,Java锁的使用

    5,了解一些设计模式。最好能把23种设计模式都看一遍,并结合自己的开发经验,看哪些可以用到设计模式,但也不能死套设计模式,要灵活运用。

    6,熟悉使用Mysql数据库

    7,了解数据库连接池的一些框架,比如Mybatis,hibernate

    8,对Http协议熟悉,熟悉一种web容器,比如tomcat,了解其配置。

    9,对常用的一些Linux命令要熟悉使用。

    10,热爱学习,不断的充实自己,上面所说的只是入门技能而已,真正做起来要复杂的多,一定要让自己喜欢游戏这个行业,这样才能有动力做下去,做自己喜欢的工作还是比为了工作要好的!


          关注公众号,了解更多

                                                                        

     

    展开全文
  • 一,游戏服务器开发的工作介绍近来遇到有很多人想从其它开发领域转到游戏服务器开发行业上来,他们或许觉得游戏服务器开发工资高,或许觉得做游戏服务器需要掌握的技术更高级,可以锻炼自己,或许觉得想换个环境等等...

    一,游戏服务器开发的工作介绍

    近来遇到有很多人想从其它开发领域转到游戏服务器开发行业上来,他们或许觉得游戏服务器开发工资高,或许觉得做游戏服务器需要掌握的技术更高级,可以锻炼自己,或许觉得想换个环境等等。不管出于什么原因吧,做为一名几年的游戏服务器开发者,当然是持欢迎态度的,那么我就先介绍一下游戏服务器开发的工作吧,游戏服务器开发具体要做哪些工作呢?

    1,团队沟通

    基本上不管做什么开发,都是一个团队来完成的,游戏也是如此,游戏团队一般由老板,总经理,CTO(技术主管),主策划(领导一些人,包括数值策划,系统策划,特效策划),主美(领导一些人,包括原画,UI设计,特效动作设计),客户端主程(领导一些人,客户端程序员,客户端程序员...),服务器主程(领导一些人,包括服务器程序员,服务器程序员),外加运维。而游戏的大部分逻辑实现与逻辑数据验证都会放在服务器端,所以服务端程序需要明确了解策划的需求,要了解就需要沟通,沟通方式的正确与否,直接关系到功能的实现是否正确,由于游戏逻辑的复杂性,单纯的文档描述可能不会非常完整,不像其它行业需求文档就几百页,详细的图文并茂,制定好之后也很少变化。所以做为一名游戏程序员,一定要有良好的沟通方式和技巧。

    2,架构设计

    这个架构设计就像盖房子打基础,基础好,房子就稳固,基础不好,房子高了就容易倒。架构设计需要结合软件工程学来搞,它需要对服务器的整个流程有足够的了解,对需求的变化有足够的认识。架构的设计一般有几个特性。

    首先是易用性,架构一旦完成,在开发的时候就要方便使用,比如网络通信架构,设计好之后,其他开发者就不需要关心客户端的数据是怎么被传输到服务器端的,这个时候对于服务器开发者来说,只需要实现一些简单的接口,就可以直接对客户端发送来的请求进行处理操作。再比如说服务器端数据的存储与更新,开发者只需要写少量SQL语句或基本不用写,都由架构的底层代码完成,开发者只需要调用封装好的API,就可以把数据存入数据库而不用关心数据的最终流向,只需要关心实现逻辑就可以了。

    第二,可扩展性,可扩展性包括两个方面,一是代码的可扩展性,比如说游戏中的任务处理吧,一个游戏中任务可能有几十种,而且还可能不定时的增加,为了判断不同的任务类型该执行什么操作,最简单也是最差的写法是if else,想象一下,一个方法里面,有几十个if else,这简单是bug的理想诞生地呀。一种可行的做法是使用责任链模式(具体的请参考设计模式的实现),这样每种任务都有一个单独的类去处理它,而不会影响其它的类,符合开闭原则,相互关联少,越少越不容易出bug。二是部署的可扩展性,比如,如果在线人数突然增加或预期可能要增加,一台物理机器可能处理不过来这么多的请求,那怎么办?那就需要支持在不影响其它服务器运行的情况下,可以动态的添加机器。而当压力降低之后,又可以移除某些机器,合理利用资源。

    第三,高吞吐量,这个是指能尽量最大化的利用计算机固定的资源,去处理更多的请求,更快速的响应客户端。这就需要在服务器架构设计的时候考虑异步处理,减少IO等待时间(比如请求redis,存储数据库,和其它服务器通信)以及数据缓存。说到异步,一定会涉及到多线程,并发等相关的技术,所以架构设计的时候需要对这部分知识有足够的了解。

    第四,要考虑是否所有的功能模块都放在同一个进程中。也就是需不需要分布式开发,哪些功能需要单独拿出来。对于手机游戏来说,一般要求同时在线量比较小,功能比较单一,所有功能都在一个进程中,人数大量同时在线时,可以多部署几组进程。而对于大型网页游戏或客户端游戏来说,特别是有些大区或不分区的情况,单个功能访问量大,服务器就要考虑分布式部署开发了。

    架构设计一般需要有经验的开发者(项目主程)去搭建,新手可以做为了解,在接触到项目之后,可以按这个思路去理解项目的架构是怎么样构成的,如果让自己来做,能否模仿出来,有时间可以自己尝试去独立设计架构,锻炼自己的能力,有一天你是会实际去做的。

    3,逻辑开发

    架构搭建完成之后,紧接着就是游戏服务器的逻辑开发,这时才开始真正去实现游戏需要的内容,比如注册,登陆,任务,活动,背包,组队战斗等。由于游戏逻辑可能需要的判断条件多,组合变化多,所以在游戏逻辑开发过程中,你会慢慢发现面向对象的重要性。逻辑开发是一个任重而道远的过程,同一个问题,可能有很多种实现方式,不同的实现方式对效率和吞吐量有很大的影响,所以就需要对需求功能的理解要深入,不同功能之间的关联要明确。对常用的设计模式要知道如何使用。比如像上面说的替换数量比较多的if else的方式。逻辑开发需要谨慎细心,而且一定要自己测试才可以,不然bug在不知不觉中就产生了。

    4,系统周边开发

    一个游戏成功的运营,需要很多服务去支持它,比如sdk接入,充值接入,日志统计,游戏运行管理系统(一般叫后台管理系统,是内部人员为了管理游戏的而开发的系统)。比如修改某个用户的等级,封号等。管理系统一般会用web开发,与游戏服务器通信。

    二,游戏类型与技术选择

    游戏服务器开发使用的技术取决于游戏的类型,不同的游戏类型,需要的游戏环境不一样,所使用的技术也不一样。但是在本质上都是一样的,都是面对数据,处理数据,不同的是面对的数量大小而已。

    1,PC类端游

    这类游戏在线人数庞大,游戏中要处理的数据也非常庞大。所以对服务器性能要求非常高,一般都是采用C++做为开发语言,C++可以直接操作内存数据,与操作系统直接交互,减少数据之间的复制,它运行效率高,处理速度快,是这类游戏开发的首选开发语言。服务器端采用分布式架构,把不同的模块分散在多台物理机上处理。需要学习的大致有C++编程,Linux网络编程、TCP/IP通讯协议、多线程编程再加数据库。它一般开发周期比较长,一个游戏的上线基本上需要三到五年。

    2,网页游戏

    这类游戏相对于端游来说,开发周期短,因为是网页游戏,游戏的界面展示依赖于网络传输,所在在画面和特效上会次于客户端游戏很多。游戏的特点主要集中在游戏的玩法上。但是对于服务器端来说,和端游类是差不多是一样的,有些公司之前是做端游的,他们就直接把端游的服务器架构拿来就可以使用,以完成快速开发。

    3,手机游戏

    手机类游戏目前是最火最热门的游戏,因为他的用户量大,用户占有时间长。但是手机游戏大多数是一般小游戏,功能简单,玩法单一,一般都是休闲娱乐的。现在也有一些稍微大型的MORPG游戏。所以手机游戏开发周期更短,上线更快。

    目前,游戏市场竞争激烈,当前服务器主流的开发语言是C++和Java,但是C++学习难度大,开发速度慢。为了满足游戏服务器快速开发,快速上线,所以一般来说我们都是使用Java语言来开发服务器。近年来,随着游戏市场的发展,游戏服务器开发技术因Java而生成了一套体系。可以供开发者选择。

    三,使用Java开发服务器需要学习什么

    Java语言,由于学习成本低,开发速度快,稳定性高,开源框架多,目前已成为网页游戏和手机游戏服务器开发的主要语言。咱们从系统的开发流程简单梳理一下服务器开发需要用到的技术。

    1,网络通信

    这个是首要实现的,如果没有网络通信,就没有服务器存在的必要了。网络通信就需要建立网络连接。目前网络通信有两种方式,一种是短连接,比如http,一种是长连接,比如socket,当然http也是基于socket的,socket是通信的基础。所以要对tcp/ip通信的知识有所了解,明白通信的原理。基于这两种网络通信,游戏服务器也分为两种,弱联网和强联网。弱联网的游戏一般是指一些小型的游戏,比如开心消消乐,连连看,以及一些卡牌养成类游戏,这类游戏一般几秒钟或几分钟再会与服务器同步一次数据,一般会使用短连接。而像一些arpg游戏,实时战斗类游戏,以及带同屏显示玩家的游戏,这类游戏与服务器交互信息频繁,一秒钟可能几十次,会采用长连接,避免每次连接重新建立消耗系统资源,提高通信效率。

    为了网络通信的效率,服务器要使用NIO(非阻塞网络通信)通信。它能支持大并发连接。Java NIO是多路复用IO,在多路复用IO模型中,会有一个线程不断去轮询多个socket的状态,只有当socket真正有读写事件时,才真正调用实际的IO读写操作。因为在多路复用IO模型中,只需要使用一个线程就可以管理多个socket,系统不需要建立新的进程或者线程,也不必维护这些线程和进程,并且只有在真正有socket读写事件进行时,才会使用IO资源,所以它大大减少了资源占用。目前基于此技术有很多开源框架,最常用的有两种,Netty和Mina。

    所以在网络通信这一块,如果是弱联网游戏,可以使用web那一套来开发游戏服务器,需要学习的技术一般有http原理,Json格式协议,servlet,Tomcat(也可以是其它web容器),spring等。如果是强联网游戏,要学习的技术有Netty或Mina可以选择一种,多线程以及线程池的应用。这是网络通信所必须掌握的。只要能把客户端发送的信息接收到,并解析成代码使用的明文,就是成功了一半了,剩下的事就是把代码封装好,方便逻辑开发调用!

    通信这块还要考虑消息的并发,长连接情况下,怎么处理断包,粘包问题,每个用户的消息处理的是不是有序的,如果有序会不会阻塞消息,如果无序会不会造成处理混乱,比如后到的消息先处理了,这些问题都要处理好,目前一般是保证同一个用户的消息要有序处理!

    2,数据存储

    网络通信调试好之后,不要急着做逻辑开发,还需要把数据如何存储理清楚!因为服务器端操作的全是数据,如果处理的不好,容易出bug,丢数据,这对游戏玩家来说是致命的,不可接受的!数据存储要考虑,一,数据如何存到数据库,是同步存储,还是异步存储!同步存储即将数操作完之后立刻写入数据库,异步操作即数据操作完之后先存储到内存缓存,然后由另外的线程或进程再同步到数据库!游戏中一般都是采用的异步存储方式,因为游戏并发量大,必须低延时,快速响应客户端!如果直接操作数据库太慢,会造成消息阻塞!内存缓存可先择的框架有redis,memcache,具体怎么同步到数据库,需要自己去设计了!二,数据接口如何设计,能不能用工作生成这些数据操作的代码,能不能不用写SQL语句,需是封装在底层,或由工具生成。编程是门艺术,在这就体现出来了,当然是仁者见仁,智者见智了!三,大并发情况下数据的一致性,像这类可能多线程操作的数据,一般是放在内存中,由锁来控制并发!所以对锁的使用要熟悉,不要出现死锁,或锁粒度过大,造成线程的长时间等待的情况!四,当数据量太大,一个数据库存储不了,数据该怎么分库分表!一种是水平划分,一种是垂直划分!具体的划分方式其它资料已有详细介绍,请自行查找阅读!目前有一个开源的分库框架mycat,是用JAVA写的,大家可以研究一下!

    3,逻辑开发

    逻辑开发就是实现游戏策划想象的各种游戏功能,比如,登录,物品使用,战斗结算等!逻辑开发代码量巨大,相互之间有很紧密的耦合性,所以每个功能模块一定要划分好!最好是接触下单元测试,写之前考虑一下是否方便单元测试,这样设计的代码会更加清晰,每个方法责任明确,不容易出bug!正是因为逻辑代码复杂,为了更好的管理代码,前辈们给我们总结了一些经验,就是著名的设计模式,所以学习一下设计模式对代码的管理有很大的好处!

    逻辑开发一般遇到的问题有:

    3.1,数据同步

    一说到数据同步或资源共享的时候,一般都会考虑到锁的使用。因为一份资源同时只能被一个线程访问才是安全的。Java的JDK中提供了一些锁,比如:synchronized,以及java.util.concurrent.lock包中的Lock对象,java.util.concurrent包中还提供了其它的一些原子操作的类,我们知道i++操作不是线程安全的,但是可以使用AtomicInteger中的getAndIncrement();方法代替,还有线程安全的ConcurrentHashMap哈稀Map。以及阻塞队列LinkedBlockingQueue等。都是逻辑开发中常用的处理数据同步的类。

    3.2,设计模式的使用

    使用设计模式,可以让代码更加清晰,可扩展性更强,维护性更佳,比如,任务系统,任务会有很多种类型,要获得任务数据时,在一开始写这个系统的时候,我是这样写的if(type == 1)做什么,else if(type == 2)做什么,else if(type == 3)......else if(type == 35) else等。如果需要添加新的类型,又要添加else,这些if else都在同一个方法中。最后都不敢动一块,就怕出bug。其实当一个方法中出现三个以上的if else将来还可能增加时,就应当考虑设计是不是有问题了,后来改成责任链模式或状态模式,就解决了这个问题。还有一个例子是,当一个值变化,要影响多个任务完成状态时,可以使用观察者模式或监听模式或订阅模式去实现,这样功能之间完全解耦,出问题的机率会很小很小。

    3.3,数据缓存框架的API使用

    目前主流使用的数据缓存框架有redis和memcache,虽然在逻辑开发前,主程会对这些进行一些封装,但是作为使用者还是需要对这些框架的客户端的使用要有所了解的。这些可以去阅读相关的文档。不是太难。

    4,程序部署与运行

    目前,大多数Java项目都采用maven管理 ,可以使用maven打包开发好的程序,程序一般运行在远程服务器上,比如云服务器。一般运行Java程序的远程服务器都是Linux系统,需要使用Linux命令操作,或写一些shell脚本去自动化部署管理一些程序。

    5,艰苦奋斗的精神

    首先,一定要让自己对这一行有兴趣,明确自己在这一行的技术选择,人生选择。很多人都知道,程序员加班是常有的事,坚持的住就做,坚持不了就再换一家公司做。

    综上所述,想做Java游戏服务器方面的开发要掌握的技术有以下一些:

    1,网络通信框架,Mina或Netty必须熟悉一种。而且自己必须要亲自搭建过,并明白其它原理。

    2,通信协议制定和处理断包粘包,这一般属于网络通信框架要解决的问题。

    3,数据缓存框架,redis或memcache选择一个,能熟练使用其客户端的命令。

    4,Java基础,Java NIO通信原理,Java集合的使用,Java多线程开发,Java锁的使用

    5,了解一些设计模式。最好能把23种设计模式都看一遍,并结合自己的开发经验,看哪些可以用到设计模式,但也不能死套设计模式,要灵活运用。

    6,熟悉使用Mysql数据库

    7,了解数据库连接池的一些框架,比如Mybatis,hibernate

    8,对Http协议熟悉,熟悉一种web容器,比如tomcat,了解其配置。

    9,对常用的一些Linux命令要熟悉使用。

    10,热爱学习,不断的充实自己,上面所说的只是入门技能而已,真正做起来要复杂的多,一定要让自己喜欢游戏这个行业,这样才能有动力做下去,做自己喜欢的工作还是比为了工作要好的!


    PS:

    java服务器目前主流框架技术有 

    网络层netty或mina 
    数据协议protobuf 
    数据库mysql 
    缓存数据库redis    jdbc一般是mybaits或者jpa 
    项目管理maven 
    设计层面spring 
    然后还需要熟悉多线程 
    linux的基本操作,git或者svn。 

    展开全文
  • java游戏服务器必备

    2018-12-28 16:41:44
    对于一个新手,想接触游戏服务器,一定会有个疑问——使用Java开发服务器需要学习什么?       Java语言,由于学习成本低,开发速度快,稳定

    推荐阅读:

          对于一个新手,想接触游戏服务器,一定会有个疑问——使用Java开发服务器需要学习什么?

          Java语言,由于学习成本低,开发速度快,稳定性高,开源框架多,目前已成为网页游戏和手机游戏服务器开发的主要语言。咱们从系统的开发流程简单梳理一下服务器开发需要用到的技术。

    1,网络通信

          这个是首要实现的,如果没有网络通信,就没有服务器存在的必要了。网络通信就需要建立网络连接。目前网络通信有两种方式,一种是短连接,比如http,一种是长连接,比如socket,当然http也是基于socket的,socket是通信的基础。所以要对tcp/ip通信的知识有所了解,明白通信的原理。
          基于这两种网络通信,游戏服务器也分为两种,弱联网和强联网。弱联网的游戏一般是指一些小型的游戏,比如开心消消乐,连连看,以及一些卡牌养成类游戏,这类游戏一般几秒钟或几分钟再会与服务器同步一次数据,一般会使用短连接。而像一些arpg游戏,实时战斗类游戏,以及带同屏显示玩家的游戏,这类游戏与服务器交互信息频繁,一秒钟可能几十次,会采用长连接,避免每次连接重新建立消耗系统资源,提高通信效率。

          为了网络通信的效率,服务器要使用NIO(非阻塞网络通信)通信。它能支持大并发连接。Java NIO是多路复用IO,在多路复用IO模型中,会有一个线程不断去轮询多个socket的状态,只有当socket真正有读写事件时,才真正调用实际的IO读写操作。因为在多路复用IO模型中,只需要使用一个线程就可以管理多个socket,系统不需要建立新的进程或者线程,也不必维护这些线程和进程,并且只有在真正有socket读写事件进行时,才会使用IO资源,所以它大大减少了资源占用。目前基于此技术有很多开源框架,最常用的有两种,Netty和Mina。

          所以在网络通信这一块,如果是弱联网游戏,可以使用web那一套来开发游戏服务器,需要学习的技术一般有http原理,Json格式协议,servlet,Tomcat(也可以是其它web容器),spring等。如果是强联网游戏,要学习的技术有Netty或Mina可以选择一种,多线程以及线程池的应用。这是网络通信所必须掌握的。只要能把客户端发送的信息接收到,并解析成代码使用的明文,就是成功了一半了,剩下的事就是把代码封装好,方便逻辑开发调用!

          通信这块还要考虑消息的并发,长连接情况下,怎么处理断包,粘包问题,每个用户的消息处理的是不是有序的,如果有序会不会阻塞消息,如果无序会不会造成处理混乱,比如后到的消息先处理了,这些问题都要处理好,目前一般是保证同一个用户的消息要有序处理!

    2,数据存储

          网络通信调试好之后,不要急着做逻辑开发,还需要把数据如何存储理清楚!因为服务器端操作的全是数据,如果处理的不好,容易出bug,丢数据,这对游戏玩家来说是致命的,不可接受的!数据存储要考虑:
          一,数据如何存到数据库,是同步存储,还是异步存储!同步存储即将数操作完之后立刻写入数据库,异步操作即数据操作完之后先存储到内存缓存,然后由另外的线程或进程再同步到数据库!游戏中一般都是采用的异步存储方式,因为游戏并发量大,必须低延时,快速响应客户端!如果直接操作数据库太慢,会造成消息阻塞!内存缓存可先择的框架有redis,memcache,具体怎么同步到数据库,需要自己去设计了!
          二,数据接口如何设计,能不能用工作生成这些数据操作的代码,能不能不用写SQL语句,需是封装在底层,或由工具生成。编程是门艺术,在这就体现出来了,当然是仁者见仁,智者见智了!
          三,大并发情况下数据的一致性,像这类可能多线程操作的数据,一般是放在内存中,由锁来控制并发!所以对锁的使用要熟悉,不要出现死锁,或锁粒度过大,造成线程的长时间等待的情况!
          四,当数据量太大,一个数据库存储不了,数据该怎么分库分表!一种是水平划分,一种是垂直划分!具体的划分方式其它资料已有详细介绍,请自行查找阅读!目前有一个开源的分库框架mycat,是用JAVA写的,大家可以研究一下!

    3,逻辑开发

          逻辑开发就是实现游戏策划想象的各种游戏功能,比如,登录,物品使用,战斗结算等!逻辑开发代码量巨大,相互之间有很紧密的耦合性,所以每个功能模块一定要划分好!最好是接触下单元测试,写之前考虑一下是否方便单元测试,这样设计的代码会更加清晰,每个方法责任明确,不容易出bug!正是因为逻辑代码复杂,为了更好的管理代码,前辈们给我们总结了一些经验,就是著名的设计模式,所以学习一下设计模式对代码的管理有很大的好处!

    逻辑开发一般遇到的问题有:

    3.1,数据同步

          一说到数据同步或资源共享的时候,一般都会考虑到锁的使用。因为一份资源同时只能被一个线程访问才是安全的。Java的JDK中提供了一些锁,比如:synchronized,以及java.util.concurrent.lock包中的Lock对象,java.util.concurrent包中还提供了其它的一些原子操作的类,我们知道i++操作不是线程安全的,但是可以使用AtomicInteger中的getAndIncrement();方法代替,还有线程安全的ConcurrentHashMap哈稀Map。以及阻塞队列LinkedBlockingQueue等。都是逻辑开发中常用的处理数据同步的类。

    3.2,设计模式的使用

          使用设计模式,可以让代码更加清晰,可扩展性更强,维护性更佳,比如,任务系统,任务会有很多种类型,要获得任务数据时,在一开始写这个系统的时候,我是这样写的if(type == 1)做什么,else if(type == 2)做什么,else if(type == 3)…else if(type == 35) else等。如果需要添加新的类型,又要添加else,这些if else都在同一个方法中。最后都不敢动一块,就怕出bug。其实当一个方法中出现三个以上的if else将来还可能增加时,就应当考虑设计是不是有问题了,后来改成责任链模式或状态模式,就解决了这个问题。还有一个例子是,当一个值变化,要影响多个任务完成状态时,可以使用观察者模式或监听模式或订阅模式去实现,这样功能之间完全解耦,出问题的机率会很小很小。

    3.3,数据缓存框架的API使用

          目前主流使用的数据缓存框架有redis和memcache,虽然在逻辑开发前,主程会对这些进行一些封装,但是作为使用者还是需要对这些框架的客户端的使用要有所了解的。这些可以去阅读相关的文档。不是太难。

    4,程序部署与运行

          目前,大多数Java项目都采用maven管理 ,可以使用maven打包开发好的程序,程序一般运行在远程服务器上,比如云服务器。一般运行Java程序的远程服务器都是Linux系统,需要使用Linux命令操作,或写一些shell脚本去自动化部署管理一些程序。

    5,艰苦奋斗的精神

          首先,一定要让自己对这一行有兴趣,明确自己在这一行的技术选择,人生选择。很多人都知道,程序员加班是常有的事,坚持的住就做,坚持不了就再换一家公司做。

    综上所述,想做Java游戏服务器方面的开发要掌握的技术有以下一些:

    1,网络通信框架,Mina或Netty必须熟悉一种。而且自己必须要亲自搭建过,并明白其它原理。

    2,通信协议制定和处理断包粘包,这一般属于网络通信框架要解决的问题。

    3,数据缓存框架,redis或memcache选择一个,能熟练使用其客户端的命令。

    4,Java基础,Java NIO通信原理,Java集合的使用,Java多线程开发,Java锁的使用

    5,了解一些设计模式。最好能把23种设计模式都看一遍,并结合自己的开发经验,看哪些可以用到设计模式,但也不能死套设计模式,要灵活运用。

    6,熟悉使用Mysql数据库

    7,了解数据库连接池的一些框架,比如Mybatis,hibernate

    8,对Http协议熟悉,熟悉一种web容器,比如tomcat,了解其配置。

    9,对常用的一些Linux命令要熟悉使用。

    10,热爱学习,不断的充实自己,上面所说的只是入门技能而已,真正做起来要复杂的多,一定要让自己喜欢游戏这个行业,这样才能有动力做下去,做自己喜欢的工作还是比为了工作要好的!
    原文:https://blog.csdn.net/qq_29166327/article/details/79433018

    展开全文
  • 本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢? 路线 Java发展到现在,按应用来分主要分为三大...

     

     

    java详细路线:

     

    原文出自点击打开链接

    本文将告诉你学习Java需要达到的30个目标,学习过程中可能遇到的问题,及学习路线。希望能够对你的学习有所帮助。对比一下自己,你已经掌握了这30条中的多少条了呢?

    路线

    Java发展到现在,按应用来分主要分为三大块:J2SE,J2ME和J2EE。

    这三块相互补充,应用范围不同。

    J2SE就是Java2的标准版,主要用于桌面应用软件的编程;

    J2ME主要应用于嵌入是系统开发,如手机和PDA的编程;

    J2EE是Java2的企业版,主要用于分布式的网络程序的开发,如电子商务网站和ERP系统。

    先学习j2se

    要学习j2ee就要先学习j2se,刚开始学习j2se先建议不要使用IDE,然后渐渐的过渡到使用IDE开发,毕竟用它方便嘛。学习j2se推荐两本书,《java2核心技术一二卷》,《java编程思想》,《java模式》。其中《java编程思想》要研读,精读。这一段时间是基本功学习,时间会很长,也可能很短,这要看学习者自身水平而定。

    不要被IDE纠缠

    在学习java和j2ee过程中,你会遇到五花八门的IDE,不要被他们迷惑,学JAVA的时候,要学语言本身的东西,不要太在意IDE的附加功能,JAVA编程在不同IDE之间的转换是很容易的,过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder,eclipse和eclipse的加强版WSAD。用好其中一个就可以了,推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。

    选择和学习服务器使用配置

    当你有了j2se和IDE的经验时,可以开始j2ee的学习了,web服务器:tomcat,勿庸置疑,tomcat为学习web服务首选。而应用服务器目前主要有三个:jboss、weblogic、websphere。有很多项目开始采用jboss,并且有大量的公司开始做websphere或weblogic向jboss应用服务器的移植(节省成本),这里要说的是,学习tomcat和jboss我认为是首选,也是最容易上手的。学习服务器使用配置最好去询问有经验的人(有条件的话),因为他们或许一句话就能解决问题,你自己上网摸索可能要一两天(我就干过这种傻事),我们应该把主要时间放在学习原理和理论上,一项特定技术的使用永远代替不了一个人的知识和学问。

    学习web知识

    如果你是在做电子商务网站等时,你可能要充当几个角色,这是你还要学习:

    html,可能要用到vscode或者webstorm或者sublime或者等IDE。

    Javascript,学会简单的数据校验,数据联动显示等等。

    J2eeAPI学习

    学习j2eeAPI和学习服务器应该是一个迭代的过程。

    先学习jsp和servlet编程,这方面的书很多,我建立看oreilly公司的两本《jsp设计》和《java servlet编程》,oreilly出的书总是那本优秀,不得不佩服。

    学习jdbc数据库编程,j2ee项目大多都是MIS系统,访问数据库是核心。这本应属于j2se学习中,这里拿出来强调一下。

    学习jndi api,它和学习ejb可以结合起来。

    学习ejb api,推荐书《精通ejb》

    经过上面的这些的学习,大概可以对付一般的应用了。

    有人说跟着sun公司的《j2ee tutorial》一路学下来,当然也可以。

    学习ejb设计模式和看代码(最重要)

    设计模式是练内功,其重要性可以这么说吧,如果你不会用设计模式的话,你将写出一堆使用了ejb的垃圾,有慢又是一堆bug,其结果不如不用ejb实现(ejb不等于j2ee)

    无论学习什么语言,都应该看大量代码,你看的代码量不到一定数量,是学不好j2ee的。

    目前有很多开源的工程可以作为教材:

    jive论坛

    petstore sun公司

    dune sun公司

    等等,研读一个,并把它用到自己的工程中来。

    J2ee其他学习

    当你渐渐对j2ee了解到一定深度时,你要开始关注当前领域中的一些技术变化,J2ee是一块百家争鸣的领域,大家都在这里提出自己的解决方案,例如structs,hiberate,ofbiz等等,学习这些东西要你的项目和目标而定,预先补充一下未尝不可,但不用涉及太深,毕竟学习原理和理论是最最重要的事。

    目前常见j2eeAPI

    JavaServer Pages(JSP)技术1.2

    Java Servlet技术2.3

    JDBC API 2.0

    Java XML处理API(JAXP)1.1

    Enterprise JavaBeans技术2.0

    Java消息服务(JMS)1.0

    Java命名目录接口(JNDI)1.2

    Java事务API(JTA) 1.0

    JavaMail API 1.2

    JavaBeans激活架构(JAF)1.0

    J2EE连接器体系结构(JCA)1.0

    Java认证和授权服务(JAAS)1.0

    学习上面的某些API要以你的项目而定,了解所有他们总之是有好处的。

    上面印证了大家说的一句话,java语言本身不难学,但是技术太多,所以学java很费劲。回想一下,基本上每个初学者,在刚学习java的时候可能都会问别人这么一句话,你怎么知道的哪个方法(api)在哪个包里的?呵呵,无他,唯手熟尔。

    1 基础是王道。我们的基础要扎实扎实再扎实。

    以上面的整个流程来看java的技术分支很多,要想完全掌握是绝对不可能的。我们只有从中精通1到2个部分。但是java也是有通性的,所谓万变不离其宗。java的所有编程思路都是“面向对象”的编程。所以大家在往更高境界发展以前一定要打好基础,这样不管以后是jree还是j3d都有应刃而解的感觉。在这里强烈推荐“java编程思想”.

    2 所谓打好基础并不是说要熟悉所有的java代码。我说的意思是要了解java的结构。class,methode,object,各种套用import,extend 让自己在结构上对java有个立体而且整体的了解即刻。其实java的学习不用固执于对代码的熟悉,1来java本身带有很多demo,java2d

    的所有问题几乎都有demo的样例。2来java是开放代码,即使没有demo网络上也有很多高手把自己的代码分享。所以不要怕没有参考,参考是到处都有的。

    3 最后还有1点经验和大家分享,对sun的api一定要学会活用,不论是学习还是作为参考api都有很大的帮助,在完全了解java的结构的基础上,不论什么方法都是可以通过api来找到的.所以不要怕找不到方法,了解结构,了解api就能找到方法。

    重点

    精通:能够掌握此技术的85%技术要点以上,使用此技术时间超过两年,并使用此技术成功实施5个以上的项目。能使用此技术优化性能或代码,做到最大可能的重用。

    熟练:能够掌握此技术的60%技术要点以上,使用此技术时间超过一年,并使用此技术成功实施3个以上的项目。能使用此技术实现软件需求并有经验的积累在实现之前能做优化设计尽可能的实现模块或代码的重用。

    熟悉:能够掌握此技术的50%技术要点以上,使用此技术时间超过半年上,并使用此技术成功实施1个以上的项目。能使用此技术实现软件需求。

    了解:可以在实际需要时参考技术文档或帮助文件满足你的需要,基本知道此项技术在你运用是所起的作用,能够调用或者使用其根据规定提供给你的调用方式。

    二:基本要求

    1:html 掌握程度:熟练。原因:不会html你可能写JSP?

    2:javascript/jscript:掌握程度:熟悉。原因:client端的数据校验、一些页面处理需要你使用脚本。

    3:CSS 掌握程度:熟悉。原因:实现页面风格的统一通常会使用css去实现。

    4:java基础编程 掌握程度:熟练。原因:不会java你能写JSP?开玩笑吧。还有你必须非常熟悉以下几个包java.lang;java.io;java.sql;java.util;java.text;javax.sevrlet;javax.servlet.http; javax.mail;等。

    5:sql 掌握程度:熟练。原因:如果你不使用数据库的话你也许不需要掌握sql。同时你必须对以下几种数据库中的一种以上的sql比较熟悉。Oracle,DB2,Mysql,Postgresql.

    6:xml 掌握程度:了解 原因:AppServer的配置一般是使用XML来实现的。

    7:ejb 掌握程度:了解 原因:很多项目中商业逻辑是由ejb来实现的,所以呢„„

    8:以下几种AppServer(engnier) 你需要了解一个以上。

    a:)Tomcat b:)WebLogic c:)WebSphere d:)JRun e:)Resin 原因:你的jsp跑在什么上面啊!

    三:选择要求(因项目而定)

    1:LDAP 掌握程度:了解 原因:LADP越来越多的运用在权限控制上面。

    2:Struts 掌握程度:熟练 原因:如果符合MVC设计通常会使用Struts实现C。

    3:Xsp 掌握程度:根据需要而定很多时候是不使用的,但在不需要使用ejb但jsp+servlet+bean实现不了的时候Xsp是一个非常不错的选择。

    4:Linux 掌握程度:熟悉 原因:如果你的运用跑在Linux/Unix上你最少要知道rm ,mv,cp,vi,tar gzip/gunzip 是用来做什么的吧。

    四:工具的使用 1:UltraEdit(EditPlus)+jakarta-ant+jakarta-log4j; 2:Jubilder4-6 3:Visual Age For Java 4:VCafe

    以上的工具你选择你自己熟悉的吧。不过强烈建议你用log4j做调试工具。

    五:成长之路

    1:html 学习时间,如果你的智商在80以上,15天时间应该够用了。至少你能手写出一个页面来。

    2:jacascript/jscript学习时间,这真的不好说,比较深奥的东西,够用的话一个礼拜可以学写皮毛。

    3:css 学习时间,三天的时间你应该知道如何使用css了,不要求你写,一般是美工来写css。

    4:java 学习时间,天才也的三个月吧。慢满学吧。如果要精通,那我不知道需要多少时间了。用来写

    jsp,四个月应该够了。

    5:sql 学习时间,只需要知道insert ,delete ,update ,select,create/drop table的话一天你应该知道了。

    6:xml 学习时间,我不知道我还没有学会呢。呵呵。不过我知道DTD是用来做什么的。

    7:ejb 学习时间,基本的调用看3天你会调用了。不过是建立在你学会java的基础上的。

    8:熟悉AppServer,Tomcat四天你可以掌握安装,配置。把jsp跑起来了。如果是WebLogic也够了,但要使用ejb那不关你的事情吧。SA做什么去了。

    9:熟悉Linux那可得需要不少时间。慢慢看man吧。

    10:Struts如果需要你再学习。

    目标

    1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF,J2EEDP)以及综合模式。你应该十分了解UML,尤其是class,object,interaction以及statediagrams。

    2. 你需要学习JAVA语言的基础知识以及它的核心类库(collections,serialization,streams, networking, multithreading,reflection,event,handling,NIO,localization,以及其他)。

    3.你应该了解JVM,classloaders,classreflect,以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。

    4. 如果你将要写客户端程序,你需要学习WEB的小应用程序(applet),必需掌握GUI设计的思想和方法,以及桌面程序的SWING,AWT, SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。

    5.你需要学习java数据库技术,如JDBCAPI并且会使用至少一种persistence/ORM构架,例如Hibernate,JDO, CocoBase,TopLink,InsideLiberator(国产JDO红工厂软件)或者iBatis。

    6.你还应该了解对象关系的阻抗失配的含义,以及它是如何影响业务对象的与关系型数据库的交互,和它的运行结果,还需要掌握不同的数据库产品运茫 热?oracle,mysql,mssqlserver。

    7.你需要学习JAVA的沙盒安全模式(classloaders,bytecodeverification,managers,policyandpermissions,

    codesigning, digitalsignatures,cryptography,certification,Kerberos,以及其他)还有不同的安全/认证 API,例如JAAS(JavaAuthenticationandAuthorizationService),JCE (JavaCryptographyExtension),JSSE(JavaSecureSocketExtension),以及JGSS (JavaGeneralSecurityService)。

    8.你需要学习Servlets,JSP,以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。

    9.你需要熟悉主流的网页框架,例如JSF,Struts,Tapestry,Cocoon,WebWork,以及他们下面的涉及模式,如MVC/MODEL2。

    10.你需要学习如何使用及管理WEB服务器,例如tomcat,resin,Jrun,并且知道如何在其基础上扩展和维护WEB程序。

    11.你需要学习分布式对象以及远程API,例如RMI和RMI/IIOP。

    12.你需要掌握各种流行中间件技术标准和与java结合实现,比如Tuxedo、CROBA,当然也包括javaEE本身。

    13.你需要学习最少一种的XMLAPI,例如JAXP(JavaAPIforXMLProcessing),JDOM(JavaforXMLDocumentObjectModel),DOM4J,或JAXR(JavaAPIforXMLRegistries)。

    14. 你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC),SAAJ (SOAPwithAttachmentsAPIforJava),JAXB(JavaArchitectureforXMLBinding),JAXM (JavaAPIforXMLMessaging), JAXR(JavaAPIforXMLRegistries),或者JWSDP(JavaWebServicesDeveloperPack)。

    15.你需要学习一门轻量级应用程序框架,例如Spring,PicoContainer,Avalon,以及它们的IoC/DI风格(setter,constructor,interfaceinjection)。

    16. 你需要熟悉不同的J2EE技术,例如JNDI(JavaNamingandDirectoryInterface),JMS (JavaMessageService),JTA/JTS(JavaTransactionAPI/JavaTransactionService), JMX (JavaManagementeXtensions),以及JavaMail。

    17.你需要学习企业级 JavaBeans(EJB)以及它们的不同组件模式:Stateless/StatefulSessionBeans,EntityBeans(包含 Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL),或者 Message-DrivenBeans(MDB)。

    18.你需要学习如何管理与配置一个J2EE应用程序服务器,如WebLogic,JBoss等,并且利用它的附加服务,例如簇类,连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。

    19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩

    写为AOP),以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。

    20. 你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing),Quartz (scheduling),JGroups(networkgroupcommunication),JCache (distributedcaching), Lucene(full-textsearch),JakartaCommons等等。

    21.如果你将要对接或者正和旧的系统或者本地平台,你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。

    22.你需要熟悉JINI技术以及与它相关的分布式系统,比如掌握CROBA。

    23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs),例如Portlets(168),JOLAP(69),DataMiningAPI(73),等等。

    24.你应该熟练掌握一种JAVAIDE例如sunOne,netBeans,IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了:)

    25.JAVA(精确的说是有些配置)是冗长的,它需要很多的人工代码(例如EJB),所以你需要熟悉代码生成工具,例如XDoclet。

    26.你需要熟悉一种单元测试体系(JNunit),并且学习不同的生成、部署工具(Ant,Maven)。

    27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。

    28.你需要能够深入了解加熟练操作和配置不同的操作系统,比如GNU/linux,sunsolaris,macOS等,做为跨平台软件的开发者。

    29.你还需要紧跟java发展的步伐,比如现在可以深入的学习javaME,以及各种java新规范,技术的运用,如新起的web富客户端技术。

    30.你必需要对opensource有所了解,因为至少java的很多技术直接是靠开源来驱动发展的,如java3D技术。(BlogJava-Topquan's Blog)

    原文出自点击打开链接

    当然学习了基础知识,也少不了了解一些数据结构与算法

    数据结构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容,如有错误,欢迎指出。

    为了便于描述,文中涉及到的代码部分都是用Java语言编写的,其实Java本身对常见的几种数据结构,线性表、栈、队列等都提供了较好的实现,就是我们经常用到的Java集合框架,有需要的可以阅读这篇文章。Java - 集合框架完全解析

    一、线性表
      1.数组实现
      2.链表
    二、栈与队列
    三、树与二叉树
      1.树
      2.二叉树基本概念
      3.二叉查找树
      4.平衡二叉树
      5.红黑树
    四、图
    五、总结
    

    一、线性表

    线性表是最常用且最简单的一种数据结构,它是n个数据元素的有限序列。

    实现线性表的方式一般有两种,一种是使用数组存储线性表的元素,即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素,即用一组任意的存储单元存储线性表的数据元素(存储单元可以是连续的,也可以是不连续的)。

    数组实现

    数组是一种大小固定的数据结构,对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后,它的大小就无法改变了,但是当数组不能再存储线性表中的新元素时,我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。

    • 代码1 创建一个更大的数组来替换当前数组
    int[] oldArray = new int[10];
            
    int[] newArray = new int[20];
            
    for (int i = 0; i < oldArray.length; i++) {
        newArray[i] = oldArray[i];
    }
    
    // 也可以使用System.arraycopy方法来实现数组间的复制     
    // System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
            
    oldArray = newArray;
    
    • 代码2 在数组位置index上添加元素e
    //oldArray 表示当前存储元素的数组
    //size 表示当前元素个数
    public void add(int index, int e) {
    
        if (index > size || index < 0) {
            System.out.println("位置不合法...");
        }
    
        //如果数组已经满了 就扩容
        if (size >= oldArray.length) {
            // 扩容函数可参考代码1
        }
    
        for (int i = size - 1; i >= index; i--) {
            oldArray[i + 1] = oldArray[i];
        }
    
        //将数组elementData从位置index的所有元素往后移一位
        // System.arraycopy(oldArray, index, oldArray, index + 1,size - index);
    
        oldArray[index] = e;
    
        size++;
    }
    

    上面简单写出了数组实现线性表的两个典型函数,具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素,比较高效,主要缺点在于插入和删除的花费开销较大,比如当在第一个位置前插入一个元素,那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率,可以采用链式结构来实现线性表。

    链表

    链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成,这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next,Next指向下一个节点,这样当添加或者删除时,只需要改变相关节点的Next的指向,效率很高。

    单链表的结构

    下面主要用代码来展示链表的一些基本操作,需要注意的是,这里主要是以单链表为例,暂时不考虑双链表和循环链表。

    • 代码3 链表的节点
    class Node<E> {
    
        E item;
        Node<E> next;
        
        //构造函数
        Node(E element) {
           this.item = element;
           this.next = null;
       }
    }
    
    • 代码4 定义好节点后,使用前一般是对头节点和尾节点进行初始化
    //头节点和尾节点都为空 链表为空
    Node<E> head = null;
    Node<E> tail = null;
    
    • 代码5 空链表创建一个新节点
    //创建一个新的节点 并让head指向此节点
    head = new Node("nodedata1");
    
    //让尾节点也指向此节点
    tail = head;
    
    • 代码6 链表追加一个节点
    //创建新节点 同时和最后一个节点连接起来
    tail.next = new Node("node1data2");
    
    //尾节点指向新的节点
    tail = tail.next;
    
    • 代码7 顺序遍历链表
    Node<String> current = head;
    while (current != null) {
        System.out.println(current.item);
        current = current.next;
    }
    
    • 代码8 倒序遍历链表
    static void printListRev(Node<String> head) {
    //倒序遍历链表主要用了递归的思想
        if (head != null) {
            printListRev(head.next);
            System.out.println(head.item);
        }
    }
    
    • 代码 单链表反转
    //单链表反转 主要是逐一改变两个节点间的链接关系来完成
    static Node<String> revList(Node<String> head) {
    
        if (head == null) {
            return null;
        }
    
        Node<String> nodeResult = null;
    
        Node<String> nodePre = null;
        Node<String> current = head;
    
        while (current != null) {
    
            Node<String> nodeNext = current.next;
    
            if (nodeNext == null) {
                nodeResult = current;
            }
    
            current.next = nodePre;
            nodePre = current;
            current = nodeNext;
        }
    
        return nodeResult;
    }
    

    上面的几段代码主要展示了链表的几个基本操作,还有很多像获取指定元素,移除元素等操作大家可以自己完成,写这些代码的时候一定要理清节点之间关系,这样才不容易出错。

    链表的实现还有其它的方式,常见的有循环单链表,双向链表,循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点,整体构成一个链环。 双向链表 主要是节点中包含两个指针部分,一个指向前驱元,一个指向后继元,JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。

    二、栈与队列

    栈和队列也是比较常见的数据结构,它们是比较特殊的线性表,因为对于栈来说,访问、插入和删除元素只能在栈顶进行,对于队列来说,元素只能从队列尾插入,从队列头访问和删除。

    栈是限制插入和删除只能在一个位置上进行的表,该位置是表的末端,叫作栈顶,对栈的基本操作有push(进栈)和pop(出栈),前者相当于插入,后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表,即后进先出。

    栈的模型

    下面我们看一道经典题目,加深对栈的理解。

    关于栈的一道经典题目

    上图中的答案是C,其中的原理可以好好想一想。

    因为栈也是一个表,所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码,可以看到它就是继承类Vector的。当然,Stack是Java2前的容器类,现在我们可以使用LinkedList来进行栈的所有操作。

    队列

    队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。

    队列示意图

    我们可以使用链表来实现队列,下面代码简单展示了利用LinkedList来实现队列类。

    • 代码9 简单实现队列类
    public class MyQueue<E> {
    
        private LinkedList<E> list = new LinkedList<>();
    
        // 入队
        public void enqueue(E e) {
            list.addLast(e);
        }
    
        // 出队
        public E dequeue() {
            return list.removeFirst();
        }
    }
    

    普通的队列是一种先进先出的数据结构,而优先队列中,元素都被赋予优先级。当访问元素的时候,具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的,比如医院的急症室为病人赋予优先级,具有最高优先级的病人最先得到治疗。在Java集合框架中,类PriorityQueue就是优先队列的实现类,具体大家可以去阅读源码。

    三、树与二叉树

    树型结构是一类非常重要的非线性数据结构,其中以树和二叉树最为常用。在介绍二叉树之前,我们先简单了解一下树的相关内容。

    ** 树 是由n(n>=1)个有限节点组成一个具有层次关系的集合。它具有以下特点:每个节点有零个或多个子节点;没有父节点的节点称为节点;每一个非根节点有且只有一个 父节点 **;除了根节点外,每个子节点可以分为多个不相交的子树。

    树的结构

    二叉树基本概念

    • 定义

    二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。

    • 相关性质

    二叉树的每个结点至多只有2棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒。

    二叉树的第i层至多有2(i-1)个结点;深度为k的二叉树至多有2k-1个结点。

    一棵深度为k,且有2^k-1个节点的二叉树称之为** 满二叉树 **;

    深度为k,有n个节点的二叉树,当且仅当其每一个节点都与深度为k的满二叉树中,序号为1至n的节点对应时,称之为** 完全二叉树 **。

    • 三种遍历方法

    在二叉树的一些应用中,常常要求在树中查找具有某种特征的节点,或者对树中全部节点进行某种处理,这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成,根节点、左子树和右子树。如果限定先左后右,那么根据这三个部分遍历的顺序不同,可以分为先序遍历、中序遍历和后续遍历三种。

    (1) 先序遍历 若二叉树为空,则空操作,否则先访问根节点,再先序遍历左子树,最后先序遍历右子树。 (2) 中序遍历 若二叉树为空,则空操作,否则先中序遍历左子树,再访问根节点,最后中序遍历右子树。(3) 后序遍历 若二叉树为空,则空操作,否则先后序遍历左子树访问根节点,再后序遍历右子树,最后访问根节点。

    给定二叉树写出三种遍历结果

    • 树和二叉树的区别

    (1) 二叉树每个节点最多有2个子节点,树则无限制。 (2) 二叉树中节点的子树分为左子树和右子树,即使某节点只有一棵子树,也要指明该子树是左子树还是右子树,即二叉树是有序的。 (3) 树决不能为空,它至少有一个节点,而一棵二叉树可以是空的。

    上面我们主要对二叉树的相关概念进行了介绍,下面我们将从二叉查找树开始,介绍二叉树的几种常见类型,同时将之前的理论部分用代码实现出来。

    二叉查找树

    • 定义

    二叉查找树就是二叉排序树,也叫二叉搜索树。二叉查找树或者是一棵空树,或者是具有下列性质的二叉树: (1) 若左子树不空,则左子树上所有结点的值均小于它的根结点的值;(2) 若右子树不空,则右子树上所有结点的值均大于它的根结点的值;(3) 左、右子树也分别为二叉排序树;(4) 没有键值相等的结点。

    典型的二叉查找树的构建过程

    • 性能分析

    对于二叉查找树来说,当给定值相同但顺序不同时,所构建的二叉查找树形态是不同的,下面看一个例子。

    不同形态平衡二叉树的ASL不同

    可以看到,含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下,当先后插入的关键字有序时,构成的二叉查找树蜕变为单支树,树的深度为n,其平均查找长度(n+1)/2(和顺序查找相同),最好的情况是二叉查找树的形态和折半查找的判定树相同,其平均查找长度和log2(n)成正比。平均情况下,二叉查找树的平均查找长度和logn是等数量级的,所以为了获得更好的性能,通常在二叉查找树的构建过程需要进行“平衡化处理”,之后我们将介绍平衡二叉树和红黑树,这些均可以使查找树的高度为O(log(n))。

    • 代码10 二叉树的节点
    
    class TreeNode<E> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    

    二叉查找树的三种遍历都可以直接用递归的方法来实现:

    • 代码12 先序遍历
    protected void preorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        System.out.println(root.element + " ");
    
        preorder(root.left);
    
        preorder(root.right);
    }
    
    • 代码13 中序遍历
    protected void inorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        inorder(root.left);
    
        System.out.println(root.element + " ");
    
        inorder(root.right);
    }
    
    • 代码14 后序遍历
    protected void postorder(TreeNode<E> root) {
    
        if (root == null)
            return;
    
        postorder(root.left);
    
        postorder(root.right);
    
        System.out.println(root.element + " ");
    }
    
    • 代码15 二叉查找树的简单实现
    /**
     * @author JackalTsc
     */
    public class MyBinSearchTree<E extends Comparable<E>> {
    
        // 根
        private TreeNode<E> root;
    
        // 默认构造函数
        public MyBinSearchTree() {
        }
    
        // 二叉查找树的搜索
        public boolean search(E e) {
    
            TreeNode<E> current = root;
    
            while (current != null) {
    
                if (e.compareTo(current.element) < 0) {
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    current = current.right;
                } else {
                    return true;
                }
            }
    
            return false;
        }
    
        // 二叉查找树的插入
        public boolean insert(E e) {
    
            // 如果之前是空二叉树 插入的元素就作为根节点
            if (root == null) {
                root = createNewNode(e);
            } else {
                // 否则就从根节点开始遍历 直到找到合适的父节点
                TreeNode<E> parent = null;
                TreeNode<E> current = root;
                while (current != null) {
                    if (e.compareTo(current.element) < 0) {
                        parent = current;
                        current = current.left;
                    } else if (e.compareTo(current.element) > 0) {
                        parent = current;
                        current = current.right;
                    } else {
                        return false;
                    }
                }
                // 插入
                if (e.compareTo(parent.element) < 0) {
                    parent.left = createNewNode(e);
                } else {
                    parent.right = createNewNode(e);
                }
            }
            return true;
        }
    
        // 创建新的节点
        protected TreeNode<E> createNewNode(E e) {
            return new TreeNode(e);
        }
    
    }
    
    // 二叉树的节点
    class TreeNode<E extends Comparable<E>> {
    
        E element;
        TreeNode<E> left;
        TreeNode<E> right;
    
        public TreeNode(E e) {
            element = e;
        }
    }
    
    

    上面的代码15主要展示了一个自己实现的简单的二叉查找树,其中包括了几个常见的操作,当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂,所以下面我详细介绍一下这里。

    • 二叉查找树中删除节点分析

    要在二叉查找树中删除一个元素,首先需要定位包含该元素的节点,以及它的父节点。假设current指向二叉查找树中包含该元素的节点,而parent指向current节点的父节点,current节点可能是parent节点的左孩子,也可能是右孩子。这里需要考虑两种情况:

    1. current节点没有左孩子,那么只需要将patent节点和current节点的右孩子相连。
    2. current节点有一个左孩子,假设rightMost指向包含current节点的左子树中最大元素的节点,而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值,将parentOfRightMost节点和rightMost节点的左孩子相连,然后删除rightMost节点。
        // 二叉搜索树删除节点
        public boolean delete(E e) {
    
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
    
            // 找到要删除的节点的位置
            while (current != null) {
                if (e.compareTo(current.element) < 0) {
                    parent = current;
                    current = current.left;
                } else if (e.compareTo(current.element) > 0) {
                    parent = current;
                    current = current.right;
                } else {
                    break;
                }
            }
    
            // 没找到要删除的节点
            if (current == null) {
                return false;
            }
    
            // 考虑第一种情况
            if (current.left == null) {
                if (parent == null) {
                    root = current.right;
                } else {
                    if (e.compareTo(parent.element) < 0) {
                        parent.left = current.right;
                    } else {
                        parent.right = current.right;
                    }
                }
            } else { // 考虑第二种情况
                TreeNode<E> parentOfRightMost = current;
                TreeNode<E> rightMost = current.left;
                // 找到左子树中最大的元素节点
                while (rightMost.right != null) {
                    parentOfRightMost = rightMost;
                    rightMost = rightMost.right;
                }
    
                // 替换
                current.element = rightMost.element;
    
                // parentOfRightMost和rightMost左孩子相连
                if (parentOfRightMost.right == rightMost) {
                    parentOfRightMost.right = rightMost.left;
                } else {
                    parentOfRightMost.left = rightMost.left;
                }
            }
    
            return true;
        }
    

    平衡二叉树

    平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1。

    平衡二叉树

    AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

    红黑树

    红黑树是平衡二叉树的一种,它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下:(1) 红黑树放弃了追求完全平衡,追求大致平衡,在与平衡二叉树的时间复杂度相差不大的情况下,保证每次插入最多只需要三次旋转就能达到平衡,实现起来也更为简单。(2) 平衡二叉树追求绝对平衡,条件比较苛刻,实现起来比较麻烦,每次插入新节点之后需要旋转的次数不能预知。点击查看更多

    四、图

    • 简介

    图是一种较线性表和树更为复杂的数据结构,在线性表中,数据元素之间仅有线性关系,在树形结构中,数据元素之间有着明显的层次关系,而在图形结构中,节点之间的关系可以是任意的,图中任意两个数据元素之间都可能相关。图的应用相当广泛,特别是近年来的迅速发展,已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

    • 相关阅读

    因为图这部分的内容还是比较多的,这里就不详细介绍了,有需要的可以自己搜索相关资料。

    (1) 《百度百科对图的介绍》
    (2) 《数据结构之图(存储结构、遍历)》

    这篇文章是常见数据结构与算法整理总结的下篇,上一篇主要是对常见的数据结构进行集中总结,这篇主要是总结一些常见的算法相关内容,文章中如有错误,欢迎指出。

    一、概述
    二、查找算法
    三、排序算法
    四、其它算法
    五、常见算法题
    六、总结
    

    一、概述

    以前看到这样一句话,语言只是工具,算法才是程序设计的灵魂。的确,算法在计算机科学中的地位真的很重要,在很多大公司的笔试面试中,算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升,花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。

    算法简介

    算法是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决,可能会存在着不同的算法,为了衡量一个算法的优劣,提出了空间复杂度与时间复杂度这两个概念。

    时间复杂度

    一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数f(n),算法的时间度量记为 ** T(n) = O(f(n)) **,它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法的渐近时间复杂度,简称时间复杂度。这里需要重点理解这个增长率。

    举个例子,看下面3个代码:
    
    1、{++x;}
    
    2、for(i = 1; i <= n; i++) { ++x; }
    
    3、for(j = 1; j <= n; j++) 
            for(j = 1; j <= n; j++) 
                 { ++x; }
    
    上述含有 ++x 操作的语句的频度分别为1 、n 、n^2,
    
    假设问题的规模扩大了n倍,3个代码的增长率分别是1 、n 、n^2
    
    它们的时间复杂度分别为O(1)、O(n )、O(n^2)
    

    空间复杂度

    空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度,记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

    二、查找算法

    查找和排序是最基础也是最重要的两类算法,熟练地掌握这两类算法,并能对这些算法的性能进行分析很重要,这两类算法中主要包括二分查找、快速排序、归并排序等等。

    顺序查找

    顺序查找又称线性查找。它的过程为:从查找表的最后一个元素开始逐个与给定关键字比较,若某个记录的关键字和给定值比较相等,则查找成功,否则,若直至第一个记录,其关键字和给定值比较都不等,则表明表中没有所查记录查找不成功,它的缺点是效率低下。

    二分查找

    • 简介

    二分查找又称折半查找,对于有序表来说,它的优点是比较次数少,查找速度快,平均性能好。

    二分查找的基本思想是将n个元素分成大致相等的两部分,取a[n/2]与x做比较,如果x=a[n/2],则找到x,算法中止;如果x<a[n/2],则只要在数组a的左半部分继续搜索x,如果x>a[n/2],则只要在数组a的右半部搜索x。

    二分查找的时间复杂度为O(logn)

    • 实现
    //给定有序查找表array 二分查找给定的值data
    //查找成功返回下标 查找失败返回-1
    
    static int funBinSearch(int[] array, int data) {
    
        int low = 0;
        int high = array.length - 1;
    
        while (low <= high) {
    
            int mid = (low + high) / 2;
    
            if (data == array[mid]) {
                return mid;
            } else if (data < array[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }
    

    三、排序算法

    排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍,并分析它们的时空复杂度。

    常见排序算法

    常见排序算法性能比较:

    图片来自网络

    上面这张表中有稳定性这一项,排序的稳定性是指如果在排序的序列中,存在前后相同的两个元素的话,排序前和排序后他们的相对位置不发生变化。

    下面从冒泡排序开始逐一介绍。

    冒泡排序

    • 简介

    冒泡排序的基本思想是:设排序序列的记录个数为n,进行n-1次遍历,每次遍历从开始位置依次往后比较前后相邻元素,这样较大的元素往后移,n-1次遍历结束后,序列有序。

    例如,对序列(3,2,1,5)进行排序的过程是:共进行3次遍历,第1次遍历时先比较3和2,交换,继续比较3和1,交换,再比较3和5,不交换,这样第1次遍历结束,最大值5在最后的位置,得到序列(2,1,3,5)。第2次遍历时先比较2和1,交换,继续比较2和3,不交换,第2次遍历结束时次大值3在倒数第2的位置,得到序列(1,2,3,5),第3次遍历时,先比较1和2,不交换,得到最终有序序列(1,2,3,5)。

    需要注意的是,如果在某次遍历中没有发生交换,那么就不必进行下次遍历,因为序列已经有序。

    • 实现
    // 冒泡排序 注意 flag 的作用
    static void funBubbleSort(int[] array) {
    
        boolean flag = true;
    
        for (int i = 0; i < array.length - 1 && flag; i++) {
    
            flag = false;
    
            for (int j = 0; j < array.length - 1 - i; j++) {
    
                if (array[j] > array[j + 1]) {
    
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
    
                    flag = true;
                }
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
    
    • 分析

    最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序,不需要进行下一次遍历,所以最佳情况下,时间复杂度为** O(n) **。

    最坏情况下冒泡排序需要n-1次遍历,第一次遍历需要比较n-1次,第二次遍历需要n-2次,...,最后一次需要比较1次,最差情况下时间复杂度为** O(n^2) **。

    简单选择排序

    • 简介

    简单选择排序的思想是:设排序序列的记录个数为n,进行n-1次选择,每次在n-i+1(i = 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。

    例如,排序序列(3,2,1,5)的过程是,进行3次选择,第1次选择在4个记录中选择最小的值为1,放在第1个位置,得到序列(1,3,2,5),第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置,得到有序序列(1,2,3,5),第3次选择因为最小的值3已经在第3个位置不需要操作,最后得到有序序列(1,2,3,5)。

    • 实现
    static void funSelectionSort(int[] array) {
    
        for (int i = 0; i < array.length - 1; i++) {
    
            int mink = i;
    
                // 每次从未排序数组中找到最小值的坐标
            for (int j = i + 1; j < array.length; j++) {
    
                if (array[j] < array[mink]) {
                    mink = j;
                }
            }
    
            // 将最小值放在最前面
            if (mink != i) {
                int temp = array[mink];
                array[mink] = array[i];
                array[i] = temp;
            }
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时,需进行n-1次比较;当i=2时,需进行n-2次比较;依次类推,共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2,即进行比较操作的时间复杂度为 O(n^2) ,进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。

    最好情况下,即待排序记录初始状态就已经是正序排列了,则不需要移动记录。最坏情况下,即待排序记录初始状态是按第一条记录最大,之后的记录从小到大顺序排列,则需要移动记录的次数最多为3(n-1)。

    简单选择排序是不稳定排序。

    直接插入排序

    • 简介

    直接插入的思想是:是将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增1的有序表。

    例如,排序序列(3,2,1,5)的过程是,初始时有序序列为(3),然后从位置1开始,先访问到2,将2插入到3前面,得到有序序列(2,3),之后访问1,找到合适的插入位置后得到有序序列(1,2,3),最后访问5,得到最终有序序列(1,2,3,5).

    • 实现
    static void funDInsertSort(int[] array) {
    
        int j;
    
        for (int i = 1; i < array.length; i++) {
    
            int temp = array[i];
    
            j = i - 1;
    
            while (j > -1 && temp < array[j]) {
    
                array[j + 1] = array[j];
    
                j--;
            }
    
            array[j + 1] = temp;
    
        }
    
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    
    • 分析

    最好情况下,当待排序序列中记录已经有序时,则需要n-1次比较,不需要移动,时间复杂度为** O(n) 。最差情况下,当待排序序列中所有记录正好逆序时,则比较次数和移动次数都达到最大值,时间复杂度为 O(n^2) 。平均情况下,时间复杂度为 O(n^2) **。

    希尔排序

    希尔排序又称“缩小增量排序”,它是基于直接插入排序的以下两点性质而提出的一种改进:(1) 直接插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。点击查看更多关于希尔排序的内容

    归并排序

    • 简介

    归并排序是分治法的一个典型应用,它的主要思想是:将待排序序列分为两部分,对每部分递归地应用归并排序,在两部分都排好序后进行合并。

    例如,排序序列(3,2,8,6,7,9,1,5)的过程是,先将序列分为两部分,(3,2,8,6)和(7,9,1,5),然后对两部分分别应用归并排序,第1部分(3,2,8,6),第2部分(7,9,1,5),对两个部分分别进行归并排序,第1部分继续分为(3,2)和(8,6),(3,2)继续分为(3)和(2),(8,6)继续分为(8)和(6),之后进行合并得到(2,3),(6,8),再合并得到(2,3,6,8),第2部分进行归并排序得到(1,5,7,9),最后合并两部分得到(1,2,3,5,6,7,8,9)。

    • 实现
        //归并排序
        static void funMergeSort(int[] array) {
    
            if (array.length > 1) {
    
                int length1 = array.length / 2;
                int[] array1 = new int[length1];
                System.arraycopy(array, 0, array1, 0, length1);
                funMergeSort(array1);
    
                int length2 = array.length - length1;
                int[] array2 = new int[length2];
                System.arraycopy(array, length1, array2, 0, length2);
                funMergeSort(array2);
    
                int[] datas = merge(array1, array2);
                System.arraycopy(datas, 0, array, 0, array.length);
            }
    
        }
    
        //合并两个数组
        static int[] merge(int[] list1, int[] list2) {
    
            int[] list3 = new int[list1.length + list2.length];
    
            int count1 = 0;
            int count2 = 0;
            int count3 = 0;
    
            while (count1 < list1.length && count2 < list2.length) {
    
                if (list1[count1] < list2[count2]) {
                    list3[count3++] = list1[count1++];
                } else {
                    list3[count3++] = list2[count2++];
                }
            }
    
            while (count1 < list1.length) {
                list3[count3++] = list1[count1++];
            }
    
            while (count2 < list2.length) {
                list3[count3++] = list2[count2++];
            }
    
            return list3;
        }
    
    • 分析

    归并排序的时间复杂度为O(nlogn),它是一种稳定的排序,java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。

    快速排序

    • 简介

    快速排序的主要思想是:在待排序的序列中选择一个称为主元的元素,将数组分为两部分,使得第一部分中的所有元素都小于或等于主元,而第二部分中的所有元素都大于主元,然后对两部分递归地应用快速排序算法。

    • 实现
    // 快速排序
    static void funQuickSort(int[] mdata, int start, int end) {
        if (end > start) {
            int pivotIndex = quickSortPartition(mdata, start, end);
            funQuickSort(mdata, start, pivotIndex - 1);
            funQuickSort(mdata, pivotIndex + 1, end);
        }
    }
    
    // 快速排序前的划分
    static int quickSortPartition(int[] list, int first, int last) {
    
        int pivot = list[first];
        int low = first + 1;
        int high = last;
    
        while (high > low) {
    
            while (low <= high && list[low] <= pivot) {
                low++;
            }
    
            while (low <= high && list[high] > pivot) {
                high--;
            }
    
            if (high > low) {
                int temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
    
        while (high > first && list[high] >= pivot) {
            high--;
        }
    
        if (pivot > list[high]) {
            list[first] = list[high];
            list[high] = pivot;
            return high;
        } else {
            return first;
        }
    }
    
    • 分析

    在快速排序算法中,比较关键的一个部分是主元的选择。在最差情况下,划分由n个元素构成的数组需要进行n次比较和n次移动,因此划分需要的时间是O(n)。在最差情况下,每次主元会将数组划分为一个大的子数组和一个空数组,这个大的子数组的规模是在上次划分的子数组的规模上减1,这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。

    最佳情况下,每次主元将数组划分为规模大致相等的两部分,时间复杂度为** O(nlogn) **。

    堆排序

    • 简介

    在介绍堆排序之前首先需要了解堆的定义,n个关键字序列K1,K2,…,Kn称为堆,当且仅当该序列满足如下性质(简称为堆性质):(1) ki <= k(2i)且 ki <= k(2i+1) (1 ≤ i≤ n/2),当然,这是小根堆,大根堆则换成>=号。

    如果将上面满足堆性质的序列看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有的非终端节点的值均不大于(或不小于)其左右孩子节点的值。

    堆排序的主要思想是:给定一个待排序序列,首先经过一次调整,将序列构建成一个大顶堆,此时第一个元素是最大的元素,将其和序列的最后一个元素交换,然后对前n-1个元素调整为大顶堆,再将其第一个元素和末尾元素交换,这样最后即可得到有序序列。

    • 实现
    //堆排序
    public class TestHeapSort {
    
        public static void main(String[] args) {
            int arr[] = { 5, 6, 1, 0, 2, 9 };
            heapsort(arr, 6);
            System.out.println(Arrays.toString(arr));
        }
    
        static void heapsort(int arr[], int n) {
    
            // 先建大顶堆
            for (int i = n / 2 - 1; i >= 0; i--) {
                heapAdjust(arr, i, n);
            }
    
            for (int i = 0; i < n - 1; i++) {
                swap(arr, 0, n - i - 1);
                heapAdjust(arr, 0, n - i - 1);
            }
        }
    
        // 交换两个数
        static void swap(int arr[], int low, int high) {
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
        }
    
        // 调整堆
        static void heapAdjust(int arr[], int index, int n) {
    
            int temp = arr[index];
    
            int child = 0;
    
            while (index * 2 + 1 < n) {
                            
                child = index * 2 + 1;
                            
                // child为左右孩子中较大的那个
                if (child != n - 1 && arr[child] < arr[child + 1]) {
                    child++;
                }
                // 如果指定节点大于较大的孩子 不需要调整
                if (temp > arr[child]) {
                    break;
                } else {
                    // 否则继续往下判断孩子的孩子 直到找到合适的位置
                    arr[index] = arr[child];
                    index = child;
                }
            }
    
            arr[index] = temp;
        }
    }
    
    
    • 分析

    由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn),空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比,堆排序在最差情况下的时间复杂度优于快排,空间效率高于归并排序。

    四、其它算法

    在上面的篇幅中,主要是对查找和常见的几种排序算法作了介绍,这些内容都是基础的但是必须掌握的内容,尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。(这里不禁想起百度一面的时候让我写二分查找和堆排序,二分查找还行,然而堆排序当时一脸懵逼...)下面主要是介绍一些常见的其它算法。

    递归

    • 简介

    在平常解决一些编程或者做一些算法题的时候,经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。

    • 经典例子

    斐波那契数列,又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入,故又称为“兔子数列”,指的是这样一个数列:0、1、1、2、3、5、8、13、21、34、……在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*)。

    //斐波那契数列 递归实现
    static long funFib(long index) {
    
        if (index == 0) {
            return 0;
        } else if (index == 1) {
            return 1;
        } else {
            return funFib(index - 1) + funFib(index - 2);
        }
    }
    

    上面代码是斐波那契数列的递归实现,然而我们不难得到它的时间复杂度是O(2^n),递归有时候可以很方便地解决一些问题,但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式,效率比递归方法的效率高。

    static long funFib2(long index) {
    
        long f0 = 0;
        long f1 = 1;
        long f2 = 1;
    
        if (index == 0) {
            return f0;
        } else if (index == 1) {
            return f1;
        } else if (index == 2) {
            return f2;
        }
    
        for (int i = 3; i <= index; i++) {
            f0 = f1;
            f1 = f2;
            f2 = f0 + f1;
        }
    
        return f2;
    }
    

    分治算法

    分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。查看更多关于分治算法的内容

    动态规划

    动态规划与分治方法相似,都是通过组合子问题的解来求解待解决的问题。但是,分治算法将问题划分为互不相交的子问题,递归地求解子问题,再将它们的解组合起来,而动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。查看更多关于动态规划的内容

    动态规划典型的一个例子是最长公共子序列问题。

    常见的算法还有很多,比如贪心算法,回溯算法等等,这里都不再详细介绍,想要熟练掌握,还是要靠刷题,刷题,刷题,然后总结。

    五、常见算法题

    下面是一些常见的算法题汇总。

    不使用临时变量交换两个数

    static void funSwapTwo(int a, int b) {
    
        a = a ^ b;
        b = b ^ a;
        a = a ^ b;
    
        System.out.println(a + " " + b);
    }
    

    判断一个数是否为素数

    static boolean funIsPrime(int m) {
    
        boolean flag = true;
    
        if (m == 1) {
            flag = false;
        } else {
    
            for (int i = 2; i <= Math.sqrt(m); i++) {
                if (m % i == 0) {
                    flag = false;
                    break;
                }
            }
        }
    
        return flag;
    }
    

    其它算法题

    1、15道使用频率极高的基础算法题
    2、二叉树相关算法题
    3、链表相关算法题
    4、字符串相关算法问题

    数据结构与算法原文出自简书尘语凡心常见数据结构与算法整理总结

    当然作为后端也要掌握一些架构师技术图谱

    展开全文
  • 题外话:推荐一个专注于Java开发的网站,做提升学习,价值阅读:Java知音 同时,扫码关注后端技术精选,回复“学习资料”,领取100套小程序源码+小程序开发视频和基本Java经典书籍电子版 在很多的网站都可以实现...

    题外话:推荐一个专注于Java开发的网站,做提升学习,价值阅读:Java知音

    同时,扫码关注后端技术精选,回复“学习资料”,领取100套小程序源码+小程序开发视频和基本Java经典书籍电子版


    在很多的网站都可以实现上传头像,可以选择自己喜欢的图片做头像,从本地上传,下次登录时可以直接显示出已经上传的头像,那么这个是如何实现的呢?

     

    下面说一下我的实现过程(只是个人实现思路,实际网站怎么实现的不太清楚)

    实现的思路:

    工具:MySQL,eclipse

    首先,在MySQL中创建了两个表,一个t_user表,用来存放用户名,密码等个人信息,

    一个t_touxiang表,用来存放上传的图片在服务器中的存放路径,以及图片名字和用户ID,

    T_touxiang表中的用户ID对应了t_user中的id。

     

    t_user表SQL:

    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user` (
      `id` int(10) NOT NULL AUTO_INCREMENT,
      `username` varchar(20) NOT NULL,
      `password` varchar(255) NOT NULL,
      PRIMARY KEY (`id`),
      UNIQUE KEY `username` (`username`)
    ) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=utf8;
    

     

    T_touxiang表SQL:

     

    DROP TABLE IF EXISTS `t_touxiang`;
    CREATE TABLE `t_touxiang` (
      `id` int(10) NOT NULL AUTO_INCREMENT,
      `image_path` varchar(255) DEFAULT NULL,
      `user_id` int(11) DEFAULT NULL,
      `old_name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `img_user` (`user_id`),
      CONSTRAINT `img_user` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
    

     

    首先,写一个UploadServlet.java,用来处理图片文件的上传,并将图片路径,图片名称等信息存放到t_touxiang数据表中,代码如下:

     

    @WebServlet("/UploadServlet.do")
    public class UploadServlet extends HttpServlet {
        private static final long serialVersionUID = 1L;
    
        protected void service(HttpServletRequest request, HttpServletResponse response)
    	    throws ServletException, IOException {
    	// 判断上传表单是否为multipart/form-data类型
    	HttpSession session = request.getSession();
    	User user = (User) session.getAttribute("user"); // 在登录时将 User 对象放入了 会话
    							 // 中
    
    	if (ServletFileUpload.isMultipartContent(request)) {
    
    	    try {
    		// 1. 创建DiskFileItemFactory对象,设置缓冲区大小和临时文件目录
    		DiskFileItemFactory factory = new DiskFileItemFactory();
    		// System.out.println(System.getProperty("java.io.tmpdir"));//默认临时文件夹
    
    		// 2. 创建ServletFileUpload对象,并设置上传文件的大小限制。
    		ServletFileUpload sfu = new ServletFileUpload(factory);
    		sfu.setSizeMax(10 * 1024 * 1024);// 以byte为单位 不能超过10M 1024byte =
    						 // 1kb 1024kb=1M 1024M = 1G
    		sfu.setHeaderEncoding("utf-8");
    
    		// 3.
    		// 调用ServletFileUpload.parseRequest方法解析request对象,得到一个保存了所有上传内容的List对象。
    		@SuppressWarnings("unchecked")
    		List<FileItem> fileItemList = sfu.parseRequest(request);
    		Iterator<FileItem> fileItems = fileItemList.iterator();
    
    		// 4. 遍历list,每迭代一个FileItem对象,调用其isFormField方法判断是否是上传文件
    		while (fileItems.hasNext()) {
    		    FileItem fileItem = fileItems.next();
    		    // 普通表单元素
    		    if (fileItem.isFormField()) {
    			String name = fileItem.getFieldName();// name属性值
    			String value = fileItem.getString("utf-8");// name对应的value值
    
    			System.out.println(name + " = " + value);
    		    }
    		    // <input type="file">的上传文件的元素
    		    else {
    			String fileName = fileItem.getName();// 文件名称
    			System.out.println("原文件名:" + fileName);// Koala.jpg
    
    			String suffix = fileName.substring(fileName.lastIndexOf('.'));
    			System.out.println("扩展名:" + suffix);// .jpg
    
    			// 新文件名(唯一)
    			String newFileName = new Date().getTime() + suffix;
    			System.out.println("新文件名:" + newFileName);// image\1478509873038.jpg
    
    			// 5. 调用FileItem的write()方法,写入文件
    			File file = new File("D:/lindaProjects/mySpace/wendao/WebContent/touxiang/" + newFileName);
    			System.out.println(file.getAbsolutePath());
    			fileItem.write(file);
    
    			// 6. 调用FileItem的delete()方法,删除临时文件
    			fileItem.delete();
    
    			/*
    			 * 存储到数据库时注意 1.保存源文件名称 Koala.jpg 2.保存相对路径
    			 * image/1478509873038.jpg
    			 * 
    			 */
    			if (user != null) {
    			    int myid = user.getId();
    			    String SQL = "INSERT INTO t_touxiang(image_path,user_id,old_name)VALUES(?,?,?)";
    			    int rows = JdbcHelper.insert(SQL, false, "touxiang/" + newFileName, myid, fileName);
    			    if (rows > 0) {
    				session.setAttribute("image_name", fileName);
    				session.setAttribute("image_path", "touxiang/" + newFileName);
    				response.sendRedirect(request.getContextPath() + "/upImage.html");
    			    } else {
    
    			    }
    
    			} else {
    			    session.setAttribute("loginFail", "请登录");
    			    response.sendRedirect(request.getContextPath() + "/login.html");
    			}
    
    		    }
    		}
    
    	    } catch (FileUploadException e) {
    		e.printStackTrace();
    	    } catch (Exception e) {
    		e.printStackTrace();
    	    }
    
    	}
        }
    }
    

     

    在完成图片上传并写入数据库的同时,将图片路径通过session的方式发送到HTML界面

     

     

    <!DOCTYPE html>
    
    <html>
    
    <head>
    
    <meta charset="UTF-8">
    
    <title>更换头像</title>
    
    </head>
    
    <body>
    
             <formaction="UploadServlet.do" method="post"enctype="multipart/form-data">
    
                         本地目录:<inputtype="file" name="uploadFile">
    
               <img src="${image_path}" width="200" height="200">
    
                    <inputtype="submit" value="上传头像"/>
    
       </form>
    
    </body>
    
    </html>

     

    至此,图片上传数据库和本地服务器已经实现,那么如何在HTML界面显示出个人信息以及上传的头像呢?

     

     

    首先定义一个PersonServlet类,用来读取数据库的内容,并发送到HTML界面。

    代码如下:

    @WebServlet("/persons.do")
    public class PersonServlet extends HttpServlet {
    
        private static final long serialVersionUID = -800352785988546254L;
    
        protected void service(HttpServletRequest request, HttpServletResponse response)
    	    throws ServletException, IOException {
    	// 判断上传表单是否为multipart/form-data类型
    	Touxiang tx=null;
    	
    	HttpSession session = request.getSession();
    	User user = (User) session.getAttribute("user"); // 在登录时将 User 对象放入了 会话
    	if(user!=null){
    	    int myid=user.getId();
    	    String SQL="SELECT id,image_path,old_name FROM t_touxiang WHERE user_id=?";
    	    ResultSet rs=JdbcHelper.query(SQL,myid);
    	    String uSQL="SELECT username,password FROM t_user WHERE id=?";
    	    ResultSet urs=JdbcHelper.query(uSQL,myid);
    	    System.out.println( "我的个人id是: " + myid);
    	    final List<Touxiang> touxiang=new ArrayList<>();
    	    try {
    		if(rs.next())
    		{
    		    tx=new Touxiang();
    		    tx.setId(rs.getInt(1));
    		    tx.setImage_path(rs.getString(2));
    		    tx.setOld_name(rs.getString(3));
    		    touxiang.add(tx);
    		}
    		if(urs.next()){
    		    user.setUsername(urs.getString(1));
    		    user.setPassword(urs.getString(2));
    		    user.setTouxiang(touxiang);
    		}
    		
    	    } catch (SQLException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	    }
    	   
    		session.setAttribute("user", user);
    		System.out.println( "我的id: " + myid);
    		response.sendRedirect( request.getContextPath() + "/person.html");
    	}
        }
    }
    

     

    在HTML界面接收信息,并显示出来,代码如下:

     

    <div>
    	<form action="UploadServlet.do" method="post" enctype="multipart/form-data">
          		 <div><a href="$path/upImage.html">更换头像</a></div>
            	
            	#foreach( $ut in  $user.getTouxiang() )
            	 <img src=" $ut.getImage_path()"  width="200" height="200">
            	 #end
            	 <div>我的头像:</div>
            	 <div>我的姓名:$user.getUsername()</div>
            	 <div><a href="$path/myAnswer.do">我的解答</a></div>
    		<div><a href="$path/myQuestion.do">我的提问</a></div>
       	 </form>
    	</div>
    <div>
    	<form action="UploadServlet.do" method="post" enctype="multipart/form-data">
          		 <div><a href="$path/upImage.html">更换头像</a></div>
            	
            	#foreach( $ut in  $user.getTouxiang() )
            	 <img src=" $ut.getImage_path()"  width="200" height="200">
            	 #end
            	 <div>我的头像:</div>
            	 <div>我的姓名:$user.getUsername()</div>
            	 <div><a href="$path/myAnswer.do">我的解答</a></div>
    		<div><a href="$path/myQuestion.do">我的提问</a></div>
       	 </form>
    	</div>

     

    至此,一个基于Java的头像上传服务器,路径存储在MySQL,并在HTML界面读取出来的功能就基本实现了。头像上传之前进行处理等操作,可以选择一些插件来完成。这里只是简单的实现了基本功能。

     

     

    补充

    对于图片上传,这里只是简单的用Servlet实现了一下最基本的功能,仅提供思路。如果使用spring等框架,他都对图片上传做了很好的封装,应该更加容易。

    后台实现图片上传应该来说比较容易,但是比较头疼的是图片上传原生的按钮丑出天际,这里推荐俩实用的上传控件,应该算比较好看。

     

    1,H5实现的图片上传,可多张上传,可点击可拖拽上传,大概是这个样子:

    基本的使用介绍和下载地址:http://blog.csdn.net/weixin_36380516/article/details/70352689

     

    2,jQuery图像裁剪插件,大概长这样

     

    不仅提供上传,还有裁剪等功能,UI做的也美,

    地址:http://www.jq22.com/jquery-info318

     

    展开全文
  • 在博主认为,对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结,前三者博主将淋漓尽致地挥毫于这篇博客文章中,至于总结在于个人,实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是...
  • 网上搜到的Java学习路线图也是一抓一大把。 今天我只选一张图,仅此一图,足以包罗Java后端技术的知识点。所谓不求最好,但求最全,学习Java后端的同学完全可以参考这张图进行学习路线安排。 当然,有一些知识点是...
  • Java服务器开发语言

    2017-06-14 16:48:54
    随着游戏市场的兴起,特别是网页游戏、手机游戏的崛起,对游戏开发技术的需求越来越多。网络游戏开发是一个庞大的体系,总体...我们公司选择使用Java服务器开发语言,主要原因是:1.Java是跨平台的,方便部署;2.Java
  • 本人尚在java 学习阶段,不是技术大咖, 自认是技术宅, 有一点写东西的能力,因最近学习java网络编程,决定手写一个web服务器,不喜勿喷,大神也请高抬贵手,不足之处还望指点一二,不胜感激! 目录结构 项目...
  • 原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我之前写的文章都是站在Java后端的全局上进行思考和总结的,忽略了很多小白们的感受,而很多朋友都需要更加基础,更加详细的学习路线。...
  • 学习java需要的软件

    2017-03-20 11:00:15
    但是很多人在开始学习Java的时候,去不知道如何下手,学习Java需要什么软件?这是很多初学者遇到的问题,下面,千锋教育给大家做一个详细的解释,希望对大家的学习有所帮助。  初学java,一般都是从控制台应用程
  • java版hls流媒体服务器

    2019-12-20 15:01:52
    java版hls流媒体服务器 1、开发的原因 一方面因为浏览器的各个厂商都在禁用flash插件导致每次观看视频流都需要授权,而移动端则完全禁用了flash。 而java版本的流媒体服务器又不多。有几个,但是文档太少。red5...
  • >在学习中,由于需要频繁抓取一些网站的数据,而且保证数据的实时性,有效性,就需要多次访问服务器。 这样的话就会增加服务器的负荷。所以网站管理员采取技术手段,对一定时间进行频繁访问的ip地址封锁处理。 ...
  • java轻量级后端应用服务器从零开始一步步搭建到上线运行...这是一个轻量级服务器搭建的系列文章,各个功能模块都被分解,一章一章的整合进去,从简单到复杂,从简陋到完善,最终就是一个完整的java后台应用服务器项目....
  • Java游戏服务器开发之行为树 之前有看到过状态机、行为树这一块的内容,但是没有认真细看,现在终于静下心来认真看了看,就看了别人的实现方式(网上代码没有Java实现的), 然后使用Java语言实现了一下 运行之后,在...
  • 那么要做Java开发,蜕变学习需要的内容有: 第一阶段,Java SE基础: Java环境搭建、Java流程控制语句-for循环、switch选择判断、循环嵌套、数组拷贝、多维数组、final关键字、构造函数的调用、类的访问权限和路径...
  • Java中最常见的5种Web服务器分别是: Tomcat、Resin、JBoss、WebSphere、WebLogic, Tomcat 服务器 目前最为流行的Tomcat服务器是Apache-Jarkarta开源项目中的一个子项目,是一个小型、轻量级的支持JSP和Servlet 技术...
  • 遇到的问题前言学习Java网络编程了,为了检验自己的学习程序和熟悉相关的知识点,为此,使用Java Socket编程实现了一个简单的FTP服务器。以下记录了自己整个开发的流程。FTP协议自己平时也有用过ftp协议进行文件的...
  • 一门永不过时的编程语言——Java 软件开发。 Java编程语言占比: 据官方数据统计,在全球编程语言工程师的数量上,Java编程语言以1000万的程序员数量位居首位。 而且很多软件的开发都离不开Java编程,因此其程序员...
  • Tomcat是一个开放源代码、运行servlet和JSP Web应用软件的基于Java的Web应用软件容器。Tomcat由Apache-Jakarta子项目支持并由来自开放性源代码Java社区的志愿者进行维护。Tomcat Server是根据servlet和JSP规范进行...
1 2 3 4 5 ... 20
收藏数 307,033
精华内容 122,813