javaee学习过程

        javaee包含了javase，然后在此基础上还使用了更多的技术。另外javaee常常跟javaweb挂钩，实际上javaee是javaweb的子集，但是个人更偏向javaee的学习，在此过程中，实际上会使用到javaweb的相关技术，但是这里着重学习javaee。

        学习javaee先从搭建环境开始，这里使用的是intellij idea+tomcat+mySQL进行的开发。

        对于intellij idea的商业版本身是需要付费的，这里在网上找到了破解的方法。

       tomcat是容器，一般认为是servlet/JSP的容器，有其他的容器可供选择，例如JBoss，glassfish等，这里学习的话，先从tomcat开始。网上下载之后，在Run->Edit Configurations上添加即可。

        mySQL是已经被Oracle收购了，另外，在使用上，似乎变得越来越麻烦了。mySQL是服务器，我们还可以使用其他的，例如Oracle，但是mySQL是免费的，而Oracle则是需要付费的。对于mySQL，可以下载msi、zip两种版本，msi可以使用exe程序引导安装，比较方便，而zip直接下载解压之后还要自己再配置，这里需要注意的是，需要在mySQL的路径下创建一个my.ini文件，这样mySQL就可以加载my.ini而不去加载my-default.ini文件了。

        然后需要注意的是，新版本的mySQL是没有data文件夹的，需要我们自己创建，我们可以：1、将my-default.ini改名成my.ini，放入bin文件夹下；2、cmd命令定位到mysql的bin文件夹下，然后执行mysqld --initialize --user = mysql --console然后data文件夹就会生成了，这里会生成一个临时密码，需要记住，后面登陆用得上；3、net start mysql启动服务；4、mysql -u root -p，然后输入命令；5、set password = password（‘密码’）这样就可以设置新密码了。

        上面这种方式是mysql5.7版本的，没有data文件夹，非常麻烦，而且上面的命令容易出错，所以不推荐使用，这里我实际上下载的是5.6版本的，这个版本的data文件夹已经有了。

        对于mySQL5.6版本的，需要注意我们使用mysqld -install安装时，他会提示我们已经安装了，但是这个安装的信息我们根本就不知道，而且这个安装，什么都做不了，各种错误。所以我们使用mysqld -remove删除，然后mysqld -install重新安装，然后就没有错误了。另外，初次安装的密码为空，输入密码时，直接enter就可以了。

        注意，在我进入到mysql命令界面之后，实际上set password = password（‘密码’）实际上并没有用。所以这里，使用的是mysqladmin -u root -p 密码，然后设置成功的。这里会有warning提示不安全，完全不用管他。

        然后我们就可以使用net start mysql开启mysql服务，使用net stop mysql服务了。ps：不要忘了关mysql服务！

        上面是使用命令行的方式操作mysql数据库。如果需要添加到idea里面去，可以在idea右边的Database窗口中添加，这里添加的类型Data Source是mySQL。另外，连接到mySQL是需要驱动的，这里跟Eclipse不一样的地方在于，idea会提示下载，然后如果点击Driver选项可以看到，实际上在C:\Users\Administrator\.IntelliJIdea15\config\jdbc-drivers\mysql-connector-java-5.1.35-bin.jar下已经有需要的驱动了，而在eclipse下，我们需要自己去下载mysql-connettor-java的驱动，然后连接。另外，mysql-connector-java-5.1.35-bin.jar就是JDBC驱动。ps：对于eclipse下的mysql-connector-java-5.1.35-bin.jar，可以在project->properties->java build path->library下添加进去就行了，web的可以放置在web-info下的lib文件夹，不是web的可以防止在tomcat下的lib文件夹下。总的来说就是让eclipse或者容器tomcat查找到mysql-connector-java-5.1.35-bin.jar就对了。另外注意idea的web项目中，web-info下没有lib文件夹，我们如果创建一个lib文件夹，并让他成为可以给我们放置jar包的地方，需要在project structure中进行设置，可以在project structure->artifacts->output layout中添加。

        实际上经过上面的设置，mysql并没有连接成功，因为设置步骤中有几个需要注意的地方。1、在intellij idea中，在Database中添加mySQL数据库，我们使用的地址是localhost的，也就是本地电脑的，可是本地电脑并不知道我们的mySQL存放的位置，所以需要我们将mySQL地址添加到环境变量；2、设置mySQL属性中，有一项Database输入框，这个框需要跟我们mySQL中创建的数据库名字一致才行，另外，如果mySQL如果没有创建数据库，那么是无论如何连接不上的；

        对于mysql，虽然可以使用cmd命令进行操作，但是最好还是使用可视化管理工具，这样更加方便。mysql的可视化管理工具有很多，这里我使用的是sqlyog，这是一个需要付费的软件，我使用的是破解版的，他和idea一样需要连接，设置的东西也和idea是一样的，这点注意！

        最后，对于本地或者服务器的连接，只需要修改地址即可。另外，localhost本地地址是127.0.0.1，但是如果直接使用这个地址，实际上会受到防火墙等的阻碍，所以最好还是使用localhost这个名称！

        其实tomcat容器和数据库应该放在服务器上面的，而不是放在本地！

        注意：服务端给我们提供数据有常见方式有servlet，webservice。servlet接受的是http请求，而webservice则是xml，但是相应的，servlet返回的是html，而webservice则可以有更多的类型和附带信息等。这里webservice是SOAP协议的！

        注意，在javaweb项目中web.xml类似于android的AndroidManifest.xml文件，在web.xml文件中的web-app标签里面的listener标签可以提供监听器，而content-param则可以提供参数等。

        这里，开发javaee，javaweb所需要的环境基本上就搭建好了，包括：intellij idea+jdk+tomcat+JDBC+mySQL。数据库工具是sqlyog。

        其实如果要学好javaee，那么必须经过学习javaweb。

        创建项目时，可能会觉得想要学习javaee就直接创建了一个java的项目，然后完成项目之后，打包成jar包放到服务器下运行即可。可实际上，不经过javaweb的学习javaee很难真正的掌握。所以这里实际上学习javaee的过程中，先要学习javaweb，或者说通过javaweb来学习javaee。所以这里创建的是一个javaweb的项目。

        在intellij idea的File->New->Project中，有很多种项目可以选择，这里选择的是Java Enterprise->Web Application项目，里面的SSH框架的添加暂时没有选择添加，后面可以自行添加，这样用于简化学习的过程。

        创建项目完成之后，项目下src文件夹和web文件夹是我们主要的文件放置地点，External Libraries是放置系统库的地方，这里由于没有使用maven构建项目，而是使用ant构建的，所以跟Eclipse下的基本一样，而External Libraries下的库基本上就是JDK，Tomcat的东西，也就是我们关联给项目之后External Libraries下添加的。也就是说：1、src下放置的文件一般跟java/android项目一样，但是如果是包名，那么最好别设置为java，这点idea跟eclipse是不一样的，idea是禁止java命名的。2、web文件夹下一般放置的是web相关的文件，例如JSP，html，tag，tld，xml等，而这中，最关键的是WEB-INF文件夹下的web.xml文件，这个文件相当于android中的AndroidManifest.xml文件，用于配置整个项目容器的相关信息，另外，WEB-INF文件夹下创建classes，lib两个文件夹，作为输出，以及放置库文件的地方，然后需要在Project Structure->Output Layout下添加，使这两个文件夹被系统知道它们的作用。

        对于掌握javaweb的编程，首先需要掌握的是javaweb的整体运行过程和整体框架。

        首先需要掌握web.xml，对于web.xml，可以从以下进行掌握：

1、可视化的参数。icon图标；display-name显示名字；welcome-file-list欢迎页列表下可以是JSP，html，action文件，servlet文件；错误页面error-page；另外还有说明description。ps：action文件是struts2的文件。

2、监听。filter和filter-mapping，listener可以实现监听，但是前者实际上应该说是过滤。

3、参数。session-conf声明会话可以设置会话时间，context-param声明应用范围内的参数，类似于android里面ids.xml文件中声明公共id。servlet和servlet-mapping声明我们自定义的Servlet子类，另外注意，每个servlet都是需要在web.xml中声明的。

4、扩展。mime-mapping应用特殊类型文件；taglib为tld文件指定别名。

5、环境以及资源。resource-env-ref资源相关管理器；resource-ref资源工厂声明的外部资源；env-entry应用环境项；login-conf与security-constraints配合使用作为用户授权应该保护的URL。

6、ejb-ref和ejb-local-ref分别声明ejb的主目录和本地主目录。

        特别注意，为了给访问的servlet或JSP名称和URL路径，使用servlet和servlet-mapping标签来设置，另外注意，JSP在编译后其实是会转换成servlet的，所以servlet和servlet-mapping标签设置JSP页面的名字和URL路径是正确的！在servlet标签中，使用jsp-file代替servlet-class元素即可。但是，servlet子类需要在web.xml中声明，而JSP却不需要。而在游戏服务器中，并没有做多个servlet，而是仅仅做一个servlet，然后让这个servlet处理左右的url转发！

        注意，在使用URL访问地址进行网页访问时，实际上访问的是servlet或者JSP。另外，在JSP文件中，网页请求中动态加载部分每次请求都可能发生变化，而html静态文件则是每次都是不变的，他们两者会被共同发送给请求者。

        而对于web.xml的加载过程：

1、容器会先去读取web.xml的listener标签和context-param标签。

2、容器将创建一个ServletContext，web项目中所有的东西都能共享这个上下文。

3、容器将context-param标签转化为键值对并交给ServletContext。

4、容器创建listener标签的监听。监听类继承自ServletContextListener

5、监听会在contextInitialized方法中返回ServletContext对象，而ServletContext.getInitParameter("key")可以得到context-param的值。

注意上面这些步骤其实就是context-param对应ServletContext，而listener对应ServletContextListener。

6、注意，在得到context-param的值之后，我们可以做一些操作，而这些操作运行时，web项目还没有启动完成，也就是说，context-param的键值所做的操作都在web项目启动完成之前。

7、这里如果想在web项目启动之前打开数据库，可以在context-param中设置数据库的连接方式，在listener监听类中初始化数据库连接。

8、总加载顺序是context-param->listener->filter->servlet，如果使用了Spring，那么顺序就是context-param->listener->filter->servlet->spring。另外，在这个过程中，同类型的节点或者说标签是根据对应的mapping的顺序进行调用的，例如filter与filter-mapping，servlet与servlet-mapping。

9、与servlet相关的类基本上都在javax.servlet.*包里面。

10、servlet对应的是Servlet类，filter标签对应的是Filter类。servlet关键是调用了service方法，而filter则是调用doFilter方法。应该说，servlet和filter是类似的。

11、特别注意，如果先加载filter在加载bean的话，bean是null，所以需要在filter中使用bean，可以将spring的加载方式改成listener的方式。

这里web.xml的大致使用就是这样的。总的来说其实就是context-param->listener->filter->servlet以及对应的类加载ServletContext->ServletContextListener->Filter->Servlet。

        在servlet的使用中，如果想要禁止连接到某一个servlet，例如我们在设置servlet和servlet-mapping中，如果url-pattern标签是缺省的，那么使用缺省的URL访问的话就会连接到这个servlet，如果我们不想要servlet被访问的话，可以使用禁止激活。这里一般有两种做法：1、重新映射/servlet/*方法，也就是servlet-mapping标签中的<url-pattern>/servlet/*<url-pattern>，这样就可以将所有的匹配项都转向所对应的servlet类了。2、关闭全局激活器servlet。这种方法是针对机器的，也就是说跟容器有关，有点容器是没有这种选项的，所以说这种方法其实不是很提倡。

        这里例举Tomcat的：1、Tomcat4容器中需要在install_dir/conf/web.xml中添加

<servlet-mapping>   
    <servlet-name>invoker</servlet-name>   
    <url-pattern>/servlet/*</url-pattern>   
</servlet-mapping>  

<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>

这里注意，不是WEB-INF/web.xml

2、Tomcat3需要在install_dir/conf/server.xml中添加：

<RequsetInterceptor className="org.apache.tomcat.request.InvokerInterceptor" debug="0" prefix="/servlet/" />   

<RequsetInterceptor className="org.apache.tomcat.request.InvokerInterceptor" debug="0" prefix="/servlet/" />

        另外，在servlet标签中，可以使用init-param标签，给servlet类一个初始化参数，如果是JSP，则将servlet-name修改成jsp-file即可。另外，在servlet类中会调用init方法，而JSP则是在代码中以加入java代码的方式调用jspinit方法，这点从JSP本身就是servlet就应该知道，JSP也有生命周期，也会被调用方法，最关键的是应该知道，JSP本身就是可以嵌入java代码的。例如下面的InitPage。jsp代码：

InitPage.jsp

Html代码 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">   
<HTML>   
<HEAD><TITLE>JSP Init Test</TITLE></HEAD>   
<BODY BGCOLOR="#FDF5E6">   
<H2>Init Parameters:</H2>   
<UL>   
<LI>First name: <%= firstName %>   
<LI>Email address: <%= emailAddress %>   
</UL>   
</BODY></HTML>   
<%!    
private String firstName, emailAddress;    
   
public void jspInit() {    
ServletConfig config = getServletConfig();    
firstName = config.getInitParameter("firstName");    
emailAddress = config.getInitParameter("emailAddress");    
}    
%>  

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>JSP Init Test</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Init Parameters:</H2>
<UL>
<LI>First name: <%= firstName %>
<LI>Email address: <%= emailAddress %>
</UL>
</BODY></HTML>
<%!
private String firstName, emailAddress;
public void jspInit() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}
%>

        在javaweb项目中还有两种文件需要掌握：tag文件和tld文件。tag文件相当于android中被include调用的文件，tag文件中可以使用JSP的除了JSP指令之外的所有操作，简单点说就是相当于JSP的部分。而tld（tag library descriptor file）文件相比tag文件，则更加严谨，类似于XML的排布，主体部分需要taglib标签包围。

        tag文件的使用只需要在JSP文件中声明<%@ taglib prefix="ui" tagdir="path" %>，然后使用使用标签<ui:xxx>的方式即可，而xxx一般是path下的tag文件。

        tld文件的使用在定义好tld文件之后，项tag文件一样在JSP文件中声明<%@ taglib prefix="ui" tagdir="path" %>，然后使用使用标签<ui:xxx>的方式即可，而xxx一般是path下的tag文件。也可以在web.xml中使用，例如：

1. <taglib>  
2. <taglib-uri>http://mytag.sf.net</taglib-uri>  
3. <taglib-location>/WEB-INF/mytag.tld</taglib-location>  
4. </taglib>

这就表示http://mytag.sf.net对应项目中/WEB-INF/mytag.tld文件。

        其实从tag的声明使用中有taglib以及tld文件内需要用taglib标签包围可以看出，实际上tag，tld都是自定义标签的使用方式。另外，tld使用上其实更强大也更复杂，而且tld使用tag-class标签可以使用类进行处理。

        注意，在web.xml中，listener类在web.xml中注册过才会被系统自动调用，如果没在web.xml中注册，就只能自行调用了，但一般情况下都是在web.xml中注册，让系统去调用的。而filter类也是一般在web.xml注册让系统去自行调用，不然的话，web项目下代码去调用将会非常不方便。总的来说就是，所有的listener类和filter类一般都是在web.xml中注册的。

        需要注意，我们使用的servlet和JSP都是需要容器提供接口和类的，分别是servlet-api.jar和jsp-api.jar两个，例如Tomcat容器的话就在Tomcat的lib文件夹下，在我们添加到web项目之后，这两个jar包将会被添加到External Libraries下。我们使用的Servlet类以及相关的类都在servlet-api.jar里面，包括Filter，FilterChain，FilterConfig类等。

        注意，filter标签需要在servlet或servlet-mapping之前，Filter类的init方法参数是FilterConfig，doFilter方法参数中有FilterChain。当不止有一个Filter时，就需要用到FilterChain，我们在Filter类的doFilter方法中，调用FilterChain的doFilter方法就可以调用Filter链的下一个Filter类了。在filter-mapping标签的url-pattern标签中可以定义需要过滤的类，filter可以过滤JSP，servlet的静态图片和静态html文件，也就是所有的固定的静态的文件基本都可以拦截。

        最关键点是程序的入口有一点需要注意，当我们没有使用welcome-file-list标签指定入口时，系统会自动寻找index.jsp，如果没有，则找index.html。如果没有index.jsp和index.html那么就会报错：The Requested Resource(/xxx) is not available。

ps：src下的资源一般使用url-pattern标签引用，而WEB-INF下的资源一般使用location标签引用。

        security-constraint标签指出那些标签需要何种保护，这个标签需要紧跟login-config之前！security-constraint包含四个可能的元素：display-name，auth-constraint，user-data-constraint，web-resource-collection。

1、web-resource-collection标签。这个标签使用web-resource-name和url-pattern标签可以指定需要保护的URL。

2、auth-constraint标签。这个标签使用role-name标签说明可以访问的URL的账户，这种方式是可移植的。用户怎么确定哪些用户处于某些角色以及口令的设置需要通过具体容器，例如Tomcat中，在install_dir/conf/user-users.xml中可以设置用户与角色和口令（密码）相关联：

<tomcat-users>   
    <user name="joe" password="bigshot" roles="administrator,kahuna" />   
    <user name="jane" password="enaj" roles="kahuna" />   
</tomcat-users>

总的来说其实就是，在容器中设置账户关联角色，然后这些角色auth-constraint标签可以用来设置是否允许访问资源。

3、user-data-constraint标签。访问相关资源需要传输层保护，这个标签下有transport-guarantee标签，标签值可以是NONE，INTEGRAL，CONFIDENTIAL三种。但是除NONE不要求之外，INTEGRAL，CONFIDENTIAL最多也就是要求简单的SSL保护而已。

4、display-name标签。这个标签给予可能由GUI工具使用的约束项一个名字而已。

        security-role-ref提供服务器专用口令文件的安全角色一个别名。例如调用request.isUserInRole(“boss”)方法的servlet，但是后来servlet被用在角色是manager而不是boss的服务器上，使用下面的程序段可以使servlet使用manager，boss中的任何一个：

<servlet>   
<!-- ... -->   
    <security-role-ref>   
        <role-name>boss</role-name> <!-- New alias -->   
        <role-link>manager</role-link> <!-- Real name -->   
    </security-role-ref>   
</servlet>  

<servlet>
<!-- ... -->
<security-role-ref>
<role-name>boss</role-name> <!-- New alias -->
<role-link>manager</role-link> <!-- Real name -->
</security-role-ref>
</servlet>

        关联文件与MIME类型：服务器一般都有让web站点管理员将文件扩展名与媒体相关联的方法。例如将会自动给予mom.jpg的文件一个image/jpeg的MIME类型。但是如果web应用具有不寻常的格式而有希望他们发送到客户机时分配为某种MIME类型时，使用mime-mapping标签可以使用，这个标签具有extension和mime-type两个标签。例如下面将application/x-fubar的MIME类型分配给.foo类型，也就是说将.foo给成.x-fobar类型：

<mime-mapping>   
    <extension>foo</extension>   
    <mime-type>application/x-fubar</mime-type>   
</mime-mapping>  

<mime-mapping>
<extension>foo</extension>
<mime-type>application/x-fubar</mime-type>
</mime-mapping>

        对于JSP中taglib的使用：

<taglib>
<taglib-uri>/charts.tld</taglib-uri>
<taglib-location>/WEB-INF/tlds/chart-tags-1.3beta.tld</taglib-location>
</taglib>

可以给tld一个文件相对web的根位置，然后我们就可以简化形式使用标签了：

<%@ taglib uri="/charts.tld" prefix="somePrefix" %>

        distributable标签支持集群服务器，可在多个服务器上部署web应用。distributable标签出现在description标签之后，只有一个<distributable/>。

        session的超时有两种方法，一种是在applicaiton中检查超时，另一种是使用监听。监听代码如下：

public class SessionBinder implements HttpSessionBindingListener {    
    public void valueBound(HttpSessionBindingEvent event){    
    //you can do anything you want!this method will be called when this binder is bind with any session.    
    }    
   
    public void valueUnbound(HttpSessionBindingEvent event) {    
    //you can do something while this session is invalidate    
    }    
}  

public class SessionBinder implements HttpSessionBindingListener {
public void valueBound(HttpSessionBindingEvent event){
//you can do anything you want!this method will be called when this binder is bind with any session.
}
public void valueUnbound(HttpSessionBindingEvent event) {
//you can do something while this session is invalidate
}
}
 

现在写好了SessionBinder，我们现在选择在一个servlet中向session中加入这个监听器——在jsp中的代码书写与此相同
//省略前面的代码，此操作可能发生在servlet的doGet方法中，也可能是doPost方法中

Java代码 
HttpSession session = req.getSession(true);//首先获得需要加入监听器的session对象，req是HttpRequest对象    
SessionBinder sb = new SessionBinder();//建立一个监听器对象    
session.putValue("BinderObject",sb);//将监听器加入此session中，从此时开始执行sb的valueBound方法  

    HttpSession session = req.getSession(true);//首先获得需要加入监听器的session对象，req是HttpRequest对象
SessionBinder sb = new SessionBinder();//建立一个监听器对象
session.putValue("BinderObject",sb);//将监听器加入此session中，从此时开始执行sb的valueBound方法

//省略后面的代码
随后，如果整个session超时或者被用户中止之后，sb的valueUnbound自动执行

        web.xml的大致使用就是这样。

        JSP，servlet，html等的学习应该注意：1、对于html文件的学习，在平常使用浏览器时，就可以学习了，使用跨借鉴F12即可打开当前网页的html代码，平常可以多看看网页的html代码加强掌握。2、JSP本质上还是servlet，所以学习JSP可以更多的借鉴servlet，同时也应该注意JSP和servlet的异同。3、servlet是javaweb的运行活动载体，相当于android的activity，所以servlet是最基础的东西，需要深刻掌握。

        JSP相比servlet，有自己的内置对象这点需要非常注意，这是可以直接引用的：request，response，session，out，page，application，pageContext，exception，config。可以分成会话4，环境3，设置2进行记忆。

1、request。这是ServletRequest类的实例，request具有请求域，在客户端请求没有完成前对象一直有效。

2、response。这是ServletResponse类的实例，response具有页面作用域，即访问一个页面时，该页面的response对象只对本次访问有效，其他页面的response对当前页面无效。

3、session。HttpSession实例。注意，一个会话指的是用户打开浏览器连接到服务器到用户关闭浏览器离开这个服务器结束。session指的是客户端与服务器的一次对话，从客户端连到服务端的WebApplication开始知道客户端与服务端断开为止，session是HttpSession的实例。当客户端访问服务器时，可能会在这个服务器的几个页面之间切换，这个时候服务器需要知道这是某个客户，这就需要session对象。

4、out。是JspWriter的实例，是向客户端输出内容的常用对象。

5、page。是Object实例。指的是页面本身，类似于java中的this。

6、application。是ServletContext的实例。application实现了用户间数据共享，可存放全局变量。application从服务器启动到服务器关闭期间一直存在，这样可以在用户的前后连接或不同用户间的连接中，对此对象的同一属性进行操作，同时在任何地方对此对象属性进行的操作都将影响到其他用户对此对象的访问。

7、exception。是Throwable的实例，如果JSP页面要使用这个对象，需要加入isErrorPage为true，否则无法编译。一旦页面发生了例外的情况，就可以产生这个对象。

8、pageContext。是PageContext实例。是当前页面上下文，可以访问JSP的对象以及命名空间，也就是说可以访问本页面所在的session。也可以取applicaiton的属性。

9、config。是ServletConfig实例。在Servlet初始化时，JSP引擎向页向他传递信息用的，此信息包括servlet初始化时需要用到的参数（属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

        上面可直接适用对象的父类是：ServletRequest，ServletResponse，ServletContext，ServletConfig，HttpSession，JspWriter，Object，Throwable，PageContext。

        servlet是java代码的，所以只需要学好javase基本没问题。

        所以总的来说，关键还是多加强JSP学习，多注意html学习。

        这里先从创建项目开始，由于使用的是intellij idea，所以这里如果是创建项目的话，其实可以供选择的创建项目的方式会更多，有java，java enterprise，maven，gradle，spring MVC等多种选择，但是应该明确的是，这些都是模板，而maven，gradle都是构建工具。我们可以从简单的入手，选择java enterprise项目，然后可以顺便选择struts 2，同时勾选创建web.xml，然后再项目创建完成之后，右键项目选择add framework support之后添加需要的支持。

        ps：在添加struts2框架后，系统会自动创建一个struts.xml文件在src文件夹下，这个文件夹如果是手动添加的话，需要在project structure->modules->Web->struts2->File Sets中点击加号，然后将struts.xml添加进来。另外，在struts2-core.jar中有一个struts-default.xml文件也需要添加进来，这个文件如果使用add framework support或者创建项目时添加struts2框架的话，一般系统会自动添加。

        需要注意的是，在idea中，项目的lib文件夹和src文件夹是同一级别的，这个lib文件夹项目时不会自动创建的，可以通过add framework support或者项目创建时添加framework work支持，例如SSH框架的方式让系统帮我们创建，当然也可以手动创建。如果我们是手动创建，忘了lib应该创建在哪里，可以右键项目然后add framework support之后点击任意框架选项，然后可以看到右边有一个configuration按钮，点击按钮可以看到框架被添加到lib下，根据这个路径我们就可以知道系统默认的lib文件夹的路径了，但是需要注意的是，如果是手动添加，一般需要注意系统是否能认定这个路径有效，所以如果一旦出错，可以在project structrure->module->dependencies中添加路径。

        在project structrure->artifacts中添加war，注意war和jar类似只是前者是web开头后者是java开头！然后再需要注意在右边有一个build on make选项可以勾选，这样每次编译项目就会构建项目。同时项目本身有一个out文件夹是和src同级别的，如果没出现，可以勾选build on make选项，然后build->make project之后out文件夹就会出来了。

        在project structure->artifacts->Output Layout下是out文件夹下的内容配置，这点需要明确，同时在Output Layout下有<output root>和WEB-INF文件夹，这里需要注意的是WEB-INF文件夹。在最开始WEB-INF文件夹右边的WEB文件夹下有选项，而这些选项都是错误的，这些错误信息在Project Structure窗口下边有显示，我们点击窗口最下边的fix按钮，然后Web文件夹下的选项会被转移到WEB-INF文件夹下，而且WEB-INF文件夹下会生成classes文件夹和lib文件夹，用lib文件夹来容纳被转移的选项。然后由于Output Layout选项下的东西最终都是出现在out文件夹下的，所以如果我们勾选了build on make选项，那么在build->Make Project之后out下会出现classes和lib文件夹。路径是out\artifacts\Web_war_exploded\WEB-INF。但是注意，out出现而web->WEB-INF文件夹下并不会生成classes和lib文件夹。ps：Web_war_exploded可以记忆成网页战争爆发。

        对于out文件夹其实是项目编译之后放置信息的位置，可以在Project Structure->Project中的Project compile output中选择路径，但一般系统会自动帮助我们配好。如果out文件夹没出来，使用Project Structure->artifacts然后勾选build on make，确定之后返回，然后点击build->make project，然后out文件夹就会出现了。

        另外，在idea中，web文件夹跟src文件夹是同一个级别的，web文件夹下有WEB-INF文件夹和index.xml文件夹，WEB-INF文件夹下有web.xml

        也就是说在idea中的web项目中，src，web，lib是同级别的。

        在学习java服务端时，其实最好使用java作为检索关键词而不是javaweb，因为javaweb更多的是前端的。

        构建项目使用gradle构建，另外，构建的时候选择gradle->java这样可以创建java项目用作服务端开发，当然如果选择gralde->web可以直接创建javaweb的项目。我们可以在选择gradle->java创建java项目之后，打开settings.gralde然后添加

apply plugin: 'war'

然后打开gradle的窗口点击刷新之后src下又出现webapp文件夹，但是没有index.jsp，而如果是gralde->web方式，会有index.jsp。

        然后打开Project Structure->module点击项目中间的项目文件夹，点击子文件，然后在Deployment Descriptors中点击添加web.xml即可。然后会创建一个WEB-INF文件夹下面添加web.xml，所以如果不修改路径的话，但是个人建议不要修改路径，这样比较安全。

        添加gradle使用jetty插件其实更好，但是这里使用Tomcat，点击Run->Edit Configurations然后点击加号添加Tomcat，这里注意，在添加界面，需要在server标签旁边的Deployment标签添加支持Tomat的包，有war、exploded两种，建议使用exploded。

        注意，使用gradle创建项目时，groupId是项目的识别码，而artifactsId是module名称。创建时，需要勾选create directories for empty content roots automatically用于创建src文件夹等。

        gradle创建的项目跟android的差不多，但是配置的时候直接在Project的build.gradle和settings.gradle进行配置即可，添加依赖直接在build.gradle进行配置即可。

        总的来说，gradle创建的项目跟一般创建的项目有所不同。gradle使用webapp文件夹，而一般的项目使用web文件夹；gradle中webapp在src/main下，而WEB-INF跟src同级别，而一般的项目则是web跟src同目录而WEB-INF在web下；在idea创建的javaweb项目中，WEB-INF的classes、lib文件夹都没有了，而是在out文件夹下，而jar包放在跟src同目录的libs文件夹下了；原本在WEB-INF文件夹下的META-INF，现在跟src同目录了，这点可以在创建java enterprise->javaee application中可以看出；WEB-INF下的tags、database.properties文件需要的时候添加。

        这里注意WEB-INF是javaweb的安全目录，客户无法访问，只有服务端可以访问。了解WEB-INF可以更好的掌握和了解javaweb。

        对于一些框架，例如SSH框架，有很多的jar包，可以网上查找需要添加的jar包。但是如果是一般的开发，那么可以在右键项目->add framework support中点击需要的框架，然后再右边的界面中，点击configuration按钮可以看到系统默认添加的jar包，我们可以根据这个列表知道我们需要添加的jar包而不用上网查。当然，最好还是上网查找需要添加的jar包，不同jar包是有不同的作用的。

        将需要的SSH框架的jar包添加到项目的lib文件夹下，然后在Project Structure->module中进行相关的设置。

        对于需要添加的SSH框架的jar包，需要掌握他们的作用，这样才能够知道自己需要使用哪些jar包。需要注意的是jar包可能有依赖性！同时应该注意，应该将框架按照模块来划分，然后这些模块由jar包构成。

        spring：不必将应用完全基于spring，只需要挑选适合的模块而忽略其他的模块就可以了。spring是基于核心容器构建的，容器定义了bean是如何创建、配置、管理的，这个容器一般可以在spring的配置文件中看到。对于spring的模块有：spring core，spring AOP，spring ORM，spring DAO，spring Context，spring Web，spring Web，spring Web MVC。

1、spring core核心容器：这是spring最基础的部分，主要实现了依赖注入特征来实现容器对bean的管理。这里最基本的概念时BeanFactory，它是任何spring应用的核心，同时他是工厂设计模式设计的，他使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。在spring的jar包中对应的是spring-core-xxx.jar。另外，还有spring-beans-xxx.jar

2、spring Context上下文：BeanFactory使spring成为容器，而spring Context使spring成为一个框架。spring Context扩展了BeanFactory概念，增加了国际化（I18N）消息和事件传播以及验证的支持。另外这个模块还提供了许多企业服务。在spring的jar包中对应的是spring-context-xxx.jar，spring-context-support-xxx.jar。

3、spring AOP面向切面：spring的AOP基于AOP联盟定义的API，所以接口规范，而且可以和其他的AOP框架互用。AOP联盟是一个开源项目，他的目标是通过定义一组共同的接口和组件来促进AOP的使用和不同AOP之间的互用性。同时spring AOP还引入了元数据编程，可以为源代码添加注解，指示spring在何处以及如何应用切面函数。在spring的jar包中对应的是spring-aop-xxx.jar。另外还有spring-aspects-xxx.jar，spring-aopalliance-xxx.jar

4、spring DAO：这里应该是JDBC抽象和DAO模块。在使用JDBC中，经常导致大量的重复代码，取得连接、创建语句、处理结果集、关闭连接等都会导致这种情况。spring的JDBC和DAO模块抽取了这部分代码，让数据库访问代码干净整洁，并且可以防止关闭数据库资源失败而引起的问题。同时这个模块还在几种数据库服务器的错误消息的基础上建立了一个有意义的异常层，这样就不用去费力破译神秘的私有的SQL错误消息。这个模块还是用了AOP模块为spring应用的对象提供了事务管理服务。在spring的jar包中对应的是spring-jdbc-xxx.jar。

5、spring ORM对象关系映射：对于不喜欢使用直接使用JDBC而是喜欢使用ORM对象关系映射的，可以使用spring提供的ORM模块。这里注意，JDBC是java数据库连接的意思，在API中使用SQL语句访问数据库，而ORM则是相当于创建了一个虚拟对象数据库。spring 的ORM并不试图实现自己的ORM解决方案，而是为几种流行的ORM提供了集成方案，分别是Hibernate，JDO，iBATIS SQL映射，spring的事务管理支持这些ORM框架中的每一个，包括JDBC，尽管JDBC不是对象关系映射。在spring的jar包中对应的是spring-orm-xxx.jar。

6、spring Web：web的上下文建立于应用的上下文，提供了一个合适于web应用的上下文。另外，这个模块还提供了一些面向服务（SOA）支持。在spring的jar包中对应的是spring-web-xxx.jar。

7、spring web MVC：spring为构建web应用提供了一个功能全面的MVC框架。虽然spring很容易与其他MVC框架集成，例如struts，但是spring提供的MVC使用IoC对控制逻辑和业务对象提供了完全的分离。他也允许声明性的将参数绑定到业务对象，此外spring的MVC还可以使用spring的其他任何服务，如国际化和验证。另外注意，intellij idea可以创建spring的MVC框架的项目。在spring的jar包中对应的是spring-webmvc-xxx.jar。

8、spring框架web页面乱码问题：在javaweb中，页面乱码问题时常都会出现，可以使用spring自带的过滤框架CharaterEncodingFilter，即简单方便也容易理解，在web.xml中配置filter如下：

<filter>

<filter-name>encodingFilter</ filter-name >

<filter-class>

org.springframework.web.filter.CharacterEncodingFilter

</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

<init-param>

<param-name>forceEncoding</param-name>

<param-value>true</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>encodingFilter</filter-name>

<url-pattern>*</url-pattern>

</filter-mapping>

这里还有使用commons-logging-xxx.jar用于调试。

        spring的核心是轻量级的IoC容器，在spring框架下有多个子框架或者说模块的组合，这些框架可以相互独立，另外也可以使用其他框架加以代替。

        总的来说，使用spring时的模块添加一般就是上面提及的模块，一般在javaweb项目中添加的jar包可以根据idea创建项目时提示需要添加的jar包来进行添加。

        hibernate是ORM关系对象映射型框架，对JDBC进行了非常轻量级的封装，使得我们可以使用OOP模式操纵数据库，hibernate可以使用在任何使用JDBC的场合，可以在java客户端使用，也可以在JSP/Servlet的web应用中使用。同时hibernate还可以代替应用EJB的j2ee框架中代替CMP，完成数据持久化的重任。

        hibernate模块一共有六个类和接口：Session，SessionFactory，Transaction，Query，Criteria，Configuration。这里需要注意，需要配置好hibernate之后才可以通过ctrl+N查找到相关的类，不然会查找不到，这点需要注意。

1、session：执行被持久化的对象的CRUD操作，同时操作时非线程安全的。这个session不同于JSP中的session，应该注意！

2、sessionFactory：使用工厂模式创建，负责初始化hibernate，数据存储源代理，初始化session。如果需要初始化多个数据库，就需要多个sessionFactory。

3、transaction：这是一个可选的接口，是对实际事务实现的一个抽象，这些实现包括JDBC的事务，JTA的UserTrasaction，甚至可以是CORBA事务。之所以这样设计是让开发者使用一个统一的事务操作界面，使得自己的项目可以在不同的环境和容器中方便的移植。

4、Query：可以使用HQL或者本地的SQL进行持久化数据的查询。经常被绑定查询参数，限制查询数量，并最终执行查询操作。

5、Criteria：Criteria和Query类似，被用于创建并执行面向对象的标准化查询，不能再session之外查询。

6、Configuration：对hibernate进行配置以及对他进行启动。Configuration实例定位映射文档的位置，然后读取配置，然后创建sessionFactory实例。Configuration是很小的不常用的，但是它是启动hibernate时遇到的第一个对象。

        在添加Hibernate到项目时，在intellij idea中使用下载方式会失败，所以只能手动添加了，这里只需要添加lib\required路径下的jar包即可。

        需要注意，hibernate有两个系列：hibernate2和hibernate3，虽然hibernate有很多版本了，但是使用最多最稳定的是是3.1.2和3.1.3.

        hibernate作为一个持久化框架有很多需要学：1、主键。2、包。3、缓存管理。4、延迟加载。5、性能优化，这些都是hibernate的高级知识点，可以在后面学习，这里先入门，避免因为复杂而容易忘记。

        struts有两个系列：struts和struts2。struts2是基于WebWork项目的，而WebWork框架的核心包是xwork-core-xxx.jar包，这也是使用struts2时为什么需要引用xwork-core-xxx.jar包的原因了。但是现在struts2系列渐渐过时了，所以但是一些旧项目还有用。

        注意，如果使用做服务端的项目，那么创建项目不是使用javaweb项目，而是使用java项目。然后再java项目里面的src再分成java、webapp、resources文件夹进行开发为好。这里注意，intellij idea已经为我们准备了需要的项目，我们可以在创建项目时选择java enterprise->javaee application创建需要的java项目，但是这个项目的结构比Eclipse下的java项目要简化很多，仅仅有META-INF和src文件夹。另外，如果是需要创建操纵数据库的项目可以选择java enterprise->javaee persistence，然后会需要下载javax.persistence.jar包，可以选择让intellij idea创建项目时下载即可。ps：java persistence是持久化也就是数据库的，是java新添加的标准。

        现在用spring MVC+myBatis开发的越来越多，所以可以从这个入手学习，而未必需要直接学习SSH，这样可以减少学习javaweb的难度。另外，myBatis是iBatis的后期版本，iBatis现在已经被google收购，所以iBatis才改名为myBatis的。

        当然Hibernate封装的比myBatis要全面点，所以也可以使用spring MVC+Hibernate进行开发。ps：如果需要使用使用spring MVC进行开发，其实是需要添加spring-webmvc-xxx.jar，spring-webmvc-portlet-xxx.jar，spring-web-xxx.jar，spring-websocket-xxx.jar包的。

        对于配置文件，需要注意，struts.xml文件一般是放在src文件夹下的，这是因为struts2的控制器org.apache.dispatcher.FilterDispatcher默认加载的是/classes下的struts.xml文件，这点可以在out文件夹下的out\artifacts\Web_war_exploded\WEB-INF\classes\struts.xml知道struts.xml确实是放在classes文件夹下的。也就是说，struts2.x的默认配置文件是放在WEB-INF/classes文件夹下的。通过修改web.xml文件可以修改struts.xml文件放置的位置：

        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
        <init-param>
            <param-name>config</param-name>
           <!-- 配置装载struts.xml路径，其中struts.xml放在/src/struts/下-->
            <param-value>struts-default.xml,struts-plugin.xml,../struts.xml</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

        注意，一般的xml文件放在WEB-INF下是比较保险的，只能通过action访问，所以可以通过上面的修改，将struts.xml文件放在WEB-INF文件夹下。

        对于spring的xml配置文件，则没有这么多的顾虑，spring的xml配置文件可以存放在其他位置，因为spring的xml配置文件都是通过配置文件找到的，例如：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>

        学习javaEE未必需要经过javaweb，相反，javaweb更多的是前端。使用spring MVC+Hibernate，或者spring MVC+myBatis可以更好的学习javaweb，而使用spring+hibernate，或者使用来学习javaEE。

        servlet需要tomcat等支持servlet/JSP的容器的支持，而hibernate作为一个轻量级的框架只需要JDK支持即可。hibernate配置文件的生成跟spring的配置文件的生成一样，在Project Structure->modules中点击中间的添加按钮并选择hibernate，然后点击最右边的添加按钮，然后会弹出hibernate.cfg.xml文件的提示，点击之后会有路径出现，可以选择路径，但是一般不修改。然后会在src/main/resources下生成hibernate.cfg.xml文件。需要注意的是，在这当中Project Structure->modules右边最底端中会提示添加hibernate包，点击Fix按钮之后自动下载jar包。注意，在创建时候hibernate总是下载失败，而此处能下载成功，猜测是因为创建项目时下载的hibernate版本较高而此时版本较低的缘故。

        这里hibernate的配置文件就完成了。需要注意的是，在Project Structure->Facets中，点击中间的项，如果hibernate或者spring这些存在黄色提示我们需要点击右边窗口最下边的Fix按钮，让hibernate和spring能连接到jar包。同时注意，Facets界面可以让jar包的结构被看到，所以在这里配置完，hibernate和spring的jar包的结构都能够被看到了，如果这里没有配置那么jar包的结构是看不到的，当然，没有配的话，使用hibernate和spring也会出错。

        需要注意的是，使用intellij idea跟使用android studio不一样，android studio使用build.gradle文件中的配置关联jar包：

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

而这种方法在intellij idea中使用的话，会打乱hibernate和spring的使用，所以使用外部jar包添加到lib文件夹之后，在Project Structure->Modules中，点击中间的项目文件夹，然后选择Dependencies选项，在点击最右边的添加按钮，然后将jar包添加进来，而这个过程实际上并不会让build.gradle有所变化！

        hibernate的使用中，需要配置一个hibernate.cfg.xml和每个javabean的.hbm.xml文件，注意，.hbm.xml文件的内容是最终存储在mysql里面的数据。注意，.hbm.xml文件需要在hibernate.cfg.xml文件中添加映射：

<mapping resource="User.hbm.xml"/>

同时注意，.hbm.xml文件一般放在resources文件夹下，跟hibernate.cfg.xml文件同目录。

        特别注意，使用hibernate时，使用到的数据库需要提前手工生成。这样才能在hibernate.cfg.xml文件中配置：

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hantest</property>

运行中程序才能找到需要的数据库。另外，表也要先手动生成，不然hibernate程序还是会找不到！ps：使用SQLYog的query编辑器时，变量名最好用间隔符·扩起来，间隔符在数字键1的左边。不然SQLYog会将变量名变成大写的。

        注意，在hibernate中存储的java对象被称为POJO对象。另外，使用SQLYog操作的数据库之后关闭的话，SQLYog会提示将操作的SQL进行存储，尾缀是.sql。

        最后生成数据库文件在mysql的data文件夹下，这里注意，如果没有怎么命名的话，会生成一个test文件夹，下面存放我们操作的数据。另外注意，其实在intellij idea->database->右键mysql->properties，然后打开Schema标签，可以看到我们的数据在下面又出现！

        spring，hibernate的使用原理基本上就是，我们操作的是XML文件，而spring，hibernate的配置文件会将这些xml文件跟相应的javabean文件映射关联，所以我们才能看起来就像是在操作xml文件一样。

        总的来说其实spring基本上就是转换bean，而hibernate就是存取bean而已，跟android的框架类似！

        java服务器搭建

未完成